Handle :opt, :key, :keyreq arguments; ignore rest

`Module#instance_method` returns an `UnboundMethod` object that you are using to scan the parameters. Those parameters are dished out as a series of two element arrays, with the first element being the argument type (`:opt` for optional arguments, `:req` for required arguments,  etc.). With the introduction of keyword arguments in ruby 2.0, there are new types, `:keyreq` and `:key` for required and optional keyword arguments, respectively.

Also, I made the assumption that optional arguments -- those arguments that have a default that ruby will use if the argument isn't specified -- should be using the injector if the injector knows how to resolve them, but should allow the default to "kick in" otherwise.

 * Method parameters of type `:keyreq` behave just like `:key`
 * `:opt` and `:key` get auto injected if the injector knows how - this means when your initializer supplies a default argument, ruse will override the default when it knows how, otherwise it will let ruby use the default.
 * There are other types of arguments, `:rest` (e.g. `*args`), `:keyrest` (`**params`), and `:block` (`&block`). `ObjectFactory` ignores these types of arguments, which means the object *will* get built by the injector even when they're part of `#initialize`'s parameters. This seemed like the least surprising behavior. If `#initialize` references a `&block` passed in, a `Ruse::Injector` has no idea how to handle that, so let the exception happen "downstream."
 * Introduce an `Initializer` object that can sift through each of the initializer method arguments, knowing how to resolve dependencies for each one.
 * Since ruby 2.0 doesn't have required keyword arguments, we don't test them. The actual code doesn't really care.