Spawning threads prior to `__AFL_INIT` is not supported as the afl++ fork server can't clone threads, see [afl++ docs](https://github.com/AFLplusplus/AFLplusplus/blob/stable/instrumentation/README.persistent_mode.md#3-deferred-initialization).

We however have chosen to do this in several of our targets (e.g. process_message, process_messages) and as a result those targets can not be fuzzed using afl++ (resulting in timeouts). Afaict this is only a problem if the spawned threads are also used (e.g. `join`) in the target.

A potential fix would be to call `initialize` after `__AFL_INIT` but prior to `__AFL_LOOP`, which will however lead to slower fuzzing for all targets.

(I'm uncertain why oss-fuzz does not report the timeouts to us but that seems like an issue on their end)
}
    std::signal(SIGABRT, signal_handler);
    const auto start_time{Now<SteadySeconds>()};
    int tested = 0;
    for (int i = 1; i < argc; ++i) {
        fs::path input_path(*(argv + i));
        if (fs::is_directory(input_path)) {
            for (fs::directory_iterator it(input_path); it != fs::directory_iterator(); ++it) {
                if (!fs::is_regular_file(it->path())) continue;
                g_input_path = it->path();
                Assert(read_file(it->path(), buffer));
                test_one_input(buffer);
                ++tested;
                buffer.clear();
            }
        } else {
            g_input_path = input_path;
            Assert(read_file(input_path, buffer));
            test_one_input(buffer);
            ++tested;
            buffer.clear();
        }
    }
    const auto end_time{Now<SteadySeconds>()};
    std::cout << g_fuzz_target << ": succeeded against " << tested << " files in " << count_seconds(end_time - start_time) << "s." << std::endl;
#endif
    return 0;
}
#endif