Both the concurrent sweep thread as well as the nursery collector will
need access to the block array.  Until we've made that lock-free,
we're simply using a lock.

The nursery collector requires that sweeping has finished, and instead
of waiting it will cooperate with the sweep thread to finish more
quickly.  The sweep thread will traverse the block array from high
indexes to low ones while the nursery collector will go from low to
high.  They will contend only very briefly when they meet somewhere in
the middle.

… held.

…read.

New blocks need to be swept if they're allocated during a non-concurrent major
collection or while a concurrent major collection is running.

It's updated from nursery collections and from the sweep thread concurrently.

Don't use the difference to the last collection, but just calculate the maximum heap
size and trigger a collection when it's reached.

And since we always wait for the sweep now we can do iterations over
the blocks without taking the lock.

We tag pointers to blocks that are currently being processed.  Those
must not even be dereferenced by other threads because the sweep
thread might free them at any point.

We cannot start threads during stop-the-world pauses (some thread APIs,
including pthreads, can deadlock), and we want to do marking and sweeping
with the same threads.  This new thread pool facility will allow that.

So we only have one worker thread that's used both for marking and,
later, for sweeping, too.