I'm so done with our control flow.

The native refactoring triggered some weird control flow bug, so I'm just
trashing it all. We know all of the JVM oddities and corner cases, and we
know how to get it equivalently right this time, but with much less code.

I've finished a first pass at a Thread implementation. I'm planning on
completely removing the RuntimeState object.

We're going to have a:
* JVM, which has a reference to a
* ThreadPool, which has references to
* Thread objects

The JVM and individual threads will have access to the bootstrap
classloader for convenience.

Instead of passing around RuntimeState, we'll pass around Thread.

Here's what needs to be done:
* [Simple] Migrate monitor logic to ThreadPool.
* [Simple] Migrate thread scheduling logic to ThreadPool.
* [Simple] Migrate JVM bootstrap logic into JVM.
  * Should be much saner this time.
* [Simple] Migrate the new native method code into JVM
  * Should be a copy+paste job.
* [Chore] Rewrite ClassLoader to use sane control flow.
  * Planning to use the async library to make it easy to execute sequences
  * of async tasks.
* [Chore] Rewrite opcodes/natives to reference *thread* rather than *runtime state*.
  * 90% regular expressions, 10% making code cleaner.
* Get the tests working again.

No more fake frames, no more stack manipulation logic in every file, no
more crazy.