Added Rubinius.lambda.
Removed not_compliant_on :rubinius guards for language/variable specs.
Added evaluate helper for method definition and parameter specs.
Added method definition and parameter specs.
Added multiple assignment specs.
Rewrote Method#arity specs.
Rewrote Proc#arity specs.
Rewrote lambda, -> {} specs.
Rewrote UnboundMethod#arity specs.
Added specs for **obj in Hash literals.
More masgn spec improvements.
Extracted coerce_to exception to a method.
A few more masgn specs.
Added keywords, arity to CompiledCode.
Fixed {Method, Proc, UnboundMethod}#arity.
Removed require for deleted spec file.
Added temporary tags for keyword method arguments.
Added temporary tags for keyword lambda arguments.
Removed tags for passing language specs.
Added Rubinius::Runtime temporarily.

Some operations in the compiler are complex and we've used the idea of a
compiler runtime providing methods to compute these complex operations at
the time the bytecode is running instead of generating bytecode ahead of
time. Since the Ruby methods are just bytecode, too, the JIT can operate
on everything, potentially inlining and it's hunky-dory and roses.

Except that we need to support multiple compilers and that means multiple
runtimes. And we want to permit the multiple compilers to be loaded into
unknown-at-bytecode-generation-time constant scopes. Consequently, bytecode
would have to somehow encode how to find the runtime at runtime.

A better approach is probably to create the idea of compiler intrinsics that
can emit bytecode directly. The source could still be a Ruby method but it
would be compiled and the resulting bytecode inlined.