Big work-stealing drop.

It's partially working, there seems to be some problem with shutdown,
but there were always problems there.
Adding next parameter to processors.

This allows processors to be used in intrusive data structures.
This would be useful for the processor queues, like the global
run-queue and the queues that are used inside the mutexes
and condition variables.
MPSC for locks, fixing MPSC node in processors.

The locks are now implemented with the MPSC queue, the nodes that
were intrusive in the processors won't work now because the tasks
already were intrusive. So now we just put a regular node in there,
and manually keep the contents in sync.

The benefits are still good: the queues that hold the processors
in theory shouldn't need any extra allocations.
Intrusive MPSC just for processors, used in mutexes.
Restore more modest executor spins.
Make sync allocation external.

This may make it possible to allocate sync on the stack later.
Use the old bounded queue.

The queue didn't appear to be a bottle-neck,
but it's nice to have the option later if it does become one.
Removing upper bound on mutex occupants.
Spin dequeue in unlock to catch waiting processor.

This was omitted from the previous change, introduced problems.
Updating benchmarks to use exit_with.

This eliminates the problems with shutdown for now, really it's just a
hackish fix though, until more thought goes into the shutdown.
Adding asserts in executor.
Remove commented out code from private queue.
Removing redundant spin from processor.
Ifdef'ing the internal queue used in task mutex.
Restructuring get_work a little to be clearer.
Updating tests for runtime.
Signal_all to notify others of queue operations.
Make sure all executor start at the same time.

A barrier is used to make sure all the executors begin at the same time.
Without this, it is possible that an executor finds NULL when it goes to
pick a victim to steal from.
Refine executor's get_work.

It uses the random number generator again, and also doesn't hit the global
queue too often, as it should be rare that things go into the global queue.
Use bitwise and to calculate index in ws_deque.