feat(maitake): add utilities for work-stealing

[hawkw]

Summary

This branch adds support for implementing work-stealing systems across
multiple schedulers to the maitake::scheduler module. In particular,
it adds the following new APIs:

• A scheduler::Injector type, representing a shared injector queue
  that can be used to spawn tasks to be executed by any of a set of
  worker Schedulers,
• A scheduler::Stealer type, which wraps a
  cordyceps::mpsc_queue::Consumer and steals tasks from an Injector
  queue or Scheduler/StaticScheduler's run queue,
• Scheduler::try_steal and StaticScheduler::try_steal methods, which
  return a Result<Stealer, TryStealError>, for attempting to steal
  tasks from a given scheduler's queue

I've also updated the mycelium::rt module to use these new APIs to
implement a global spawn with work-stealing across multiple cores.

Implementation Notes

In order to implement work-stealing, it was necessary to modify the
Task type to allow the scheduler field stored by the task to be
changed after the task is created. This may occur when a task is stolen
from one scheduler by another, or when a task is spawned on a shared
Injector queue and not yet bound to a scheduler.

This required changing the scheduler field to an UnsafeCell.
Currently, access to the UnsafeCell is controlled by the task's state
bits, and the current state system is sufficient for ensuring a task is
not bound to a new scheduler while it's queued.

Tasks can only be re-bound to the same type of scheduler, since the
size of the stored scheduler field must be the same when rebinding.
Currently, this is checked by a debug assertion in the Task code, and
the work-stealing APIs use PhantomData to prevent tasks from being
stolen from a scheduler of one type and spawned by a scheduler of a
different type.

Future Work

Some things that this branch doesn't do, but I'd like to get to in the
future:

• Consider adding support in maitake for setting a global Injector
  queue to use with an ambiently-available task::spawn function?
• Consider changing how tasks store the Schedule reference so that
  the UnsafeCell can be replaced with an AtomicPtr. This would
  probably require one of the following:
  • Changing the Schedule trait to have clone_scheduler(*const ())
    and drop_scheduler(*const ()) or similar, to hook into ref counting
    for the Arc scheduler,
  • Type-erasing Schedule instances with another custom vtable. That
    could potentially permit stealing tasks from a scheduler of one
    type onto a scheduler of a different type, if the vtable could also
    be changed (requiring a vtable pointer...)
• Make the Injector queue work with the task::Builder API.
  Currently, tasks configured with a builder must be spawned on a real
  Scheduler, and cannot be spawned on an Injector. It would be nice
  to fix that.
• Write more docs, including:
  • Guide level docs on how to implement work-stealing. I didn't write
    this yet because I'm lazy and want to get this PR merged sooner...
  • Add examples in the API docs