Massive commit with a bunch of changes. Class loading and initialization are now asynchronous. As a result, many core JVM operations that previously relied upon having a 'Type' object could no longer be used synchronously because they invoked class lookup functions. In addition, using 'Type' objects for class lookups is ambiguous; classes are defined by their name AND the class loader that loaded them.

To fix this, I changed most of these core methods to take ClassFile objects, which is currently the definitive object for reference types.

We are moving toward #116; we will soon move away from passing around Type objects and toward passing around ClassFile objects, which has become the standard representation of Java classes. Once we start stashing ClassFile objects in StackFrames for easy access from opcodes and such, we can stop using types in a large number of places.

In a move to fix #124, I have changed the function signature for class_lookup / load_class / define_class / jclass_obj to include the class that triggered the lookup / load / etc. This is used to determine the correct ClassLoader to invoke class loading. This is *not* hooked up at the call sites yet since we do not have ClassFiles there to pass in, but we eventually *will* hook those up, which should fix this issue.

For #127, as mentioned all class loading is performed in an asynchronous manner. I believe this is the last difficult internal JVM matter that we needed to convert for WebWorker support. I'll be able to port over my frontend changes once the internal details stabilize.

I believe #138 is fixed? I need to grep through the code to ensure we no longer use any synchronous node API calls, except for those that work on file descriptors (since those do not invoke file loading/closing).

There are a number of new "hacks" denoted with "XXX". Many of these have to do with ClassLoading, which will be fixed once we move toward actually having ClassLoader objects that handle that abstraction. I'll open an issue for that.

A few native methods have become a little crufty, especially those related to reflection. Some have to manipulate the stack while in an async_op, and I had to carefully orchestrate their stack changes such that they do not interfere with what async_op does. I may want to consider making a better helper function for these complex tasks, but I suppose that should wait until we have proper Thread objects that have a nice API for manipulating the stack.

Other than that, things are looking positive. We should move toward eliminating Type objects and cleaning up the code.
Merge branch 'master' of https://github.com/int3/doppio