Start prototyping runtime policy API
Implement MethodHandlePrototype and a couple RuntimePolicies

- finish implementing MethodHandlePrototype
  * add getters and setters
  * implement a reasonable constructor
  * split bake into owner resolution and method handle creation
- add a couple implementations of RuntimePolicy:
  * PassthruPolicy, which always directly returns handle from
    the prototype
  * LoggingPolicy, which prints to stderr all methods being intercepted
    and passes the call to another policy
Start implementing infrastructure for setting RuntimePolicy

- add a static field in Bootstraps to hold the RuntimePolicy,
  and add accessors for that field
- add BMClassLoader for loading Bootstraps class mutliple times,
  which will allow us to have per-classloader runtime policies
Move method name constants to Bootstraps

Many classes need to know the name of certain methods of the Bootstrap
class. They keep these names in constatns.

Move these constants to the Bootstrap class, so that whenever someone
renames one of the methods, he can also easily change the name in the
constant.
Start using RuntimePolicy

- make Bootstraps.makeHandle() get the handles from policy instead of
  just creating them
- make the test classes setup the classloader environment properly and 
  set the policy
Make sure BMClassLoader loads the Bootstraps class before setting policy
Fix a few bugs in BMClassLoader

- append '.class' to the class'es internal name before using it
  as a resource name
- throw more informative exceptions when unable to load the resource
- make sure we don't define the same package twice
- make sure we don't load the Bootstraps class from our parent classloader
  by wrapping it with a FilteringClassLoader that will filter out
  the Bootstraps class

The last one - yeah, I know I could do it w/o the FilteringClassLoader
trick, but I'd have to copy/reimplement the whole
ClassLoader.loadClass(String name, boolean resolve) except without
the parent.loadClass call.
Add more functionality to MethodHandlePrototype
Add a temporary solution to non-intercepting of initializers

This should make it possible to leave a constructor call unintercepted
without messing up the stack.