Don't do this in header files.

The main thread has a bogus wait_for_interrupts() which consumed wakeups,
so the scheduler on the cpu running it could not schedule stuff.  This
manifested itself in lots of zombies from bsd callouts not getting reaped.

Drop.

If the user forgot to do this, do them a favour.

We also make the deleter configurable so we can use munmap() or similar
to destroy the stack of payload threads.

Mutex is much better now and should be sufficient.

To avoid overflowing sem_t, we have to use a pointer instead of embedding
the mutex.

This reverts commit e917ab25.

If we have an assert, it can break badly, as printf() inside the assert
allocates.

Will reinstate after adding emergency allocators.

Mutexes are now allocation free and thus safe for use within the allocator.

wait_until(mutex, ...) must be called with the mutex held.

Use the new wait_until() variant that supports dropping a mutex
while sleeping.

We need to make them a little more complicated.

Previously, we performed idle processing in the scheduler, in the context
of the thread that is being scheudled out.  This makes preemption more
complicated, since every thread can potentially be in the idle loop
simultaneously, having been preempted there some time in the past.  Obviously
we can't disable interrupts in the idle loop.

Move idle processing to its own thread to fix this problem.  This is currently
sub-optimal since we don't have priority classes yet (or even just priorities),
so the idle thread can be scheduled before workload threads.  If that happens
it will examine the runqueue and yield if there's anything there.

These variants unlock a mutex while sleeping (but keep it locked while
evaluating the predicate) and thus are suitable for more complicated
predicates that cannot be evaluated atomically.

Will need more interaction with the scheduler.

Otherwise, expect memory corruption.

Make sure sched::tls is initialized before we create objects of type 'cpu',
so that any threads in those objects (idle thread, etc.) are initialized
correctly.

See README for instructions.