Part 1 of the Great Bytecode Drudgery.

Bytecodes are now 100% responsible for incrementing the program counter.
Before, we had tons of awful hacks that hacked around the implicit PC
increment in the main bytecode loop. Now, bytecodes are responsible.

I've also added a flag to the BytecodeStackFrame that signals when the
bytecode loop should return to the thread runner. This adds a little extra
responsibility to the bytecodes, as they now need to set the flag if they:
* Throw an exception.
* Return.

I'm might add a helper later for these.

Return opcodes now check if they are returning from a synchronized method,
and now appropriately call monitorexit. No more terrible hackery!

You may wonder why I switched from lambda syntax to function syntax.
Lambdas do not allow me to reference `this`, whereas functions do. I need
`this` to run `this.incPc()`. Unfortunately, TypeScript has no idea what
`this` refers to, so these lambda'd opcodes are going to be partially
untyped.

Finally, we used to 'resolve methods' by ensuring that all exception
classes are resolved prior to the method running. I've removed that
requirement, and have a TODO in there to make exception handling
asynchronous, giving us the freedom to lazily resolve exception classes.

It's going to be interesting to see how performance changes after I'm
done.

Also, did I mention that our type coverage is getting better and better?
The nasty bits of DoppioJVM were largely untyped. Now we have types
everywhere. Yay!