Using an AlarmFuture blocks the Fiber executing Actor::waitUntilIdle,
freeing its current worker and thus preventing life-locks.
Where all workers are sleeping except one.
Which executes the Actor::waitUntilIdle Fiber causing a starvation of
the actual Actor.

A spurious wake-up can be produced by the new UnblockOnMainActorTest which
triggers the assert(!mpscQueue.empty()) in UnboundedBlockingMpscQueue::get.

Those spurious wake-ups are possible because the push and wake-up pair in
UnboundedBlockingMpscQueue::put are not atomic.
The following sequence diagram demonstrates a spurious wake-up:

   T1          T2            Q
   .           .            { }
  put(e)       .            { }
 push 54-57    .            {e}
   .         get()          {e}
   .        consume e       { }
   .           .            { }
   .         get()          { }
   .         block          { }
 unblock       .            { }
   .           .            { }
   .         wakeup         { }
   .           .            { }
               X
       assert(!queue.Empty())

To deal with spurious wake-ups we recheck the wake-up condition (a non empty queue)
and block again if we find it empty.
We assume spurious wake-ups are rare because it was difficult to reproduce them
even with a dedicated Test (the new UnblockOnMainActorTest) therefore we declare
the empty queue branch as unlikely.

Fixes #4.

We are unable to switch to C++20 until
https://github.com/mesonbuild/meson/issues/8084 is fixed.

In debug builds, the schedule() method is now guarded by an assert(),
as due to this change, the schedule() method will no longer work from
everywhere.

This also improves the worker sleep method.

And fix the #include issues reported by the newer IWYU version.

Introduce a new Actor test using BinaryPrivateSemaphores and an Actor.
Multiple fibers are created which create a BPS on the stack, submit it to the actor
and wait on the semaphore.
The Actor simply signals each semaphore it receives.