support AOT-compilation of Java 8 lambda expressions

These expressions are tricky because they rely on invokedynamic, which
normally implies runtime code generation.  However, since lambdas
don't actually use the "dynamicness" of invokedynamic, we can convert
them into static calls to synthetic classes at compile time.

Since I had already written code to synthesize such classes in Java
and I didn't want to rewrite it in C++, I needed to add support for
running Java code to the bootimage generator.  And since the primary
VM used by the generator is purpose-built to generate AOT-compiled
code for a specific target architecture and is not capable of
generating or running JIT-compiled code for the host architecture, I
added support for loading a second, independent, host-specific VM for
running Java code.

The rest of the patch handles the fact that each method compilation
might cause new, synthetic classes to be created, so we need to make
sure those classes and their methods are included in the final heap
and code images.  This required breaking some giant code blocks out of
makeCodeImage into their own methods, which makes the diff look
scarier than it really is.

classpath/java/lang/invoke/MethodHandle.java

@@ -1,6 +1,7 @@
 package java.lang.invoke;
 
 import avian.Classes;
+import avian.SystemClassLoader;
 
 public class MethodHandle {
   static final int REF_invokeStatic = 6;
@@ -17,6 +18,20 @@ public class MethodHandle {
     this.method = method;
   }
 
+  MethodHandle(String class_,
+               String name,
+               String spec,
+               int kind)
+  {
+    this.kind = kind;
+    this.loader = SystemClassLoader.appLoader();
+    try {
+      this.method = Classes.findMethod(this.loader, class_, name, spec);
+    } catch (ClassNotFoundException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   public String toString() {
     StringBuilder sb = new StringBuilder();
     if (method.class_ != null) {