Eventfd's does not support seeking. This is also invalid code:

int main() {
    int64_t b = 42;
    int efd = eventfd(0, 0);
    if (efd < 0) err(EXIT_FAILURE, "creating eventfd failed");
    ssize_t res = pwrite(efd, &b, sizeof(b), 0);
    if (res != sizeof(b)) err(EXIT_FAILURE, "pwrite to evfd failed");
}

This also fixes a bug in
	 source = test_dict['source'][0]
so the source(s) used for the test was always only the first source
file. I did/does not matter, as we do not have tests that span
multiple source files (and I am not sure if we ever will have).

Add a message to help investigate CI failures for single-uring
configurations like:
https://gitlab.cs.fau.de/i4/manycore/emper/-/jobs/574828

LinuxVersion::compare reported two versions as equal if it could
find a new '.' in the first version but not in the second.
But this is clearly wrong because it skips comparision of the valid last
part.

The comparision 5.16.12 >= 5.18 returned true because compare
reported the version as equal after comparing the first parts and
finding a second '.' in the first but not the second.

Fix this behavior by marking the current position as the last but
do not skip its comparision.

Add tests for the desired behaviour.

To avoid confusing the fork with a heavyweight (Unix) fork(), we use
spawn/sync instead of fork/join in Fibril.

EMPER's Runtime now installs the SIGSEGV handler that checks if the
segmentation fault was caused by hitting the guard page. If the guard
page was hit, then the handler prints an error message.

Also make ContextOutOfBoundsTest more robust by not creating an
infinite recursion, which may be optmized out by the compiler.

Add an SIGSEGV handler to the ContextOutOfBoundsTest to ensure that
the received SIGSEGV is caused by accessing the guard page.

The test is a simple infinite recursion hitting the guard page.
The new guard-page-test-runner skips the test if emper::STACK_GUARD_PAGE
is false.

Thanks to Nicolas Pfeiffer for writing the initial prototypical
implementation of continuation stealing and the cactus stack
mechanism, on which this is based.

Co-authored-by: Nicolas Pfeiffer <pfeiffer@cs.fau.de>

Test more Fiber functionality in Future callbacks: blocking and spawning.

The alpha fiber waits to ensure the worker threads are suspended before
starting to schedule work on specific threads.
emper::sleep uses an AlarmFuture and thus needs emper to be build with IO
support. If IO is not available we now just block the whole worker thread.

LinuxVersion used the assumption that both strings have the same
amount of dot-separated components.
But this is obviously not always the case.
If we can't compare the two strings further they must been equal so far.

A getter not calling sem.wait is needed so we don't call sem.wait twice:
once during Future::cancel() and Future::wait() to obtain the return
value afterwards.

Our only cancellation test case where it is possible that the cancellation
must happen on a specific worker uses a single fiber.
The introduced massCancelOnDifferentWorker() test case uses
workerCount * 5 fibers and actively tries to provoke cancellation on
other workers.

Remember the IoContext where a Future was prepared and submit
the CancelWrapper on the correct Worker using scheduleOn.

This function is needed to deal with worker local ressources: io_uring
requests for example.

Each worker now always has a MPSC inbox queue which was already used
in the laws scheduling strategy.
Fibers can be scheduled to a specific worker using the new
Scheduler::scheduleOn method.

Since the inbox queues are now always present we can use a single
FiberSource enum combining AbstractWorkStealingStrategy::FiberSource
and LawsStrategy::FiberSource.

The laws strategy now uses the inbox queues as its priority queues.
With the only differenze that when scheduling to a inbox queue
using the Scheduler::scheduleOn the Fiber lifes only in the inbox
queue and not also simultaneously in a WSQ.

Unrelated code changes made while touching the code anyway:
* Introduce FiberSource::io which hints that a Fiber comes from the
  worker's own CQ.
* Strongly type the fiber's source in NextFiberResult.
* Make all scheduler functions return std::optional<NextFiberResult>
* Cleanup the identation in nextFiberResultViaWorkStealing

I could not identify the commit that changes this behavior but
it is reproducible on our bigboxes and my arch system.

The UnblockOnMainActorTest regularly timeout in our CI
which looks to be a regular timeout because I could easily reproduce
the timeout on fauibig03.

Hopefully this change fixes regular timeouts like
https://gitlab.cs.fau.de/aj46ezos/emper/-/jobs/506757
in the CI and only leaves real faulty timeouts.

* Document data races of a future's state.
* Get and set a Future's state only through methods. This helps to
  add possibly needed atomic operations.
* Use atomics to get/set cancel and prepare state in IO_SINGLE_URING vaiant
* Add more IO debug messages
* Use the BPS of Futures with callbacks similar to those of forgotten
  ones to signal their preparation. The preparation mark the
  last moment where the Future is used in EMPER and after that the memory
  can be dropped.
  ATTENTION: This means not that the used resources of the IO request
  can be dropped. The kernel may still use a supplied buffer for example.
* Fix Future chain cancellation in SubmitActor

Currently canceling Futures would never happen because we
issued the cancel request only with the pointer of the future.
This works more by coincidence than by design because
the PointerTags::Future tagged onto the submitted future pointer is 0.

This does not work for callbacks because they are tagged with a
PointerTags != 0 and they don't use their callback pointer rather
than the future pointer.

Fix this by exporting the tagging from IoContext::prepareFutureChain
into IoContext::createFutureTag and use this when submitting a cancel
sqe.

Warn the user that they have to manually take care of the memory safety
of the callback because we can not await the callback in Future::cancel.

Add a test case to CancelFutureTest.

This makes the test closer to our echoserver.

I suspect some test which scale whith the number of CPUs to timeout
mostly on jenkins2.
This patch reduces the load when logging is active and increases the
load when logging is off.
Therefore our test build with debugoptimized will do less and hopefully
only timeout when they actually hung and the release test will do
more.

The test introduces multiple cycles of Semaphores and
a Fiber for each semaphore blocking and signaling the next.
Through work-stealing the fibers from a cycle should be spread
across different workers and thus test concurrent use of
BinaryPrivateSemaphores.

Cycle of length 3: Sem A -> Sem B -> Sem C -> Sem A -> ...
Algorithm:
	if isFirstInCycle
		signal next

	wait

	if not isFirstInCycle
		signal next

While we do not have yet LLVM 13 in the gitlab-ci, I use it on my
systems. So fix the new warnings found with clang-tidy 13.

The chosen amounts of echos take on my 16 core ryzen system ~5seconds.
This should hopefully reduce CI timeout where we are not sure if they are
bugs or legit timeouts. Furthermore this should reduce the amount of logs
we write and have to store after each CI run.

Before 05dc56ed the two test cases testDiskAndNetwork, testIov
where combined in one function which was terminating the runtime after the client
closed its socketafter the test was done.
This was already broken before 05dc56ed but after the separation of the
two use cases the race between the Runtime terminating and the execution of
the last parts of the test-runner's alphaFiber became bigger.

When the Runtime terminates because the last worker running the testIoV
code has outstanding IO the test-runner's successSem is never notified.

* Use more emper io functions
* Split the separate test cases into two functions
* Use C++ arrays where sensible

The tests may fail when repeated because the listener may bind to fast
to the tcp tuple again. This is fixed by using SO_REUSEPORT instead of SO_REUSEADDR.

TIL: SO_REUSEADDR is about address wildcards and SO_REUSEPORT allows
binding to the same tcp tuple.
https://stackoverflow.com/questions/14388706/how-do-so-reuseaddr-and-so-reuseport-differ

Add a generic way to specify socket options when creating a listen socket
with tcp_listener.

* remove fancy but broken static LinuxVersion object.
  This means each usage of a EMPER_LINUX_* macro results in a syscall.
  But I think this is worth it when the result is a sound program.
  Users of those macros should store the result of the comparison anyway.
* fix that we skipped parsing the last part of a version string
* add a test for LinuxVersion
* IO_MUST_INVALIDATE_BROKEN_CHAIN can still be const

This allows use to remove the current hack that the test are always
build without NDEBUG regardless of the meson buildtype.

Which is fact fixes the failing io tests in release builds.
Because Future.hpp and Future.cpp see the same version of NDEBUG.