Clear frame name when duplicating it for a class body. Fixes #1402
Remove unnecessary synchronization from initObjectId. Fixes #1400.

The synchronization here is not actually necessary since the
variable accessor has already been allocated and the object's
monitor has already been acquired (both in getObjectId, the sole
caller of initObjectId). This synchronization caused global
bottlenecks against a given class, since it synchronized against
the VariableTableManager instance from that class. Since it's
likely that if user code acquires an object_id from one instance
of a class, it will acquire object_id from all instances of the
class...this quickly ran into multithreaded contention.

I opted to remove the synchronization, because I believe it is
safe, and modified initObjectId's visibility to be private so it
won't mistakenly be called by external code.
Move SecureRandom.random_bytes to native, to avoid JI costs.
Use a per-thread SecureRandom and move #hex into native.
the script which created the bat only worked if bin/jirb.bat was there and writable - which might have been the error for #1409

[skip ci]
Don't use iterator for walking nodes to avoid allocating one.
AVoid allocating NextJump when result is just nil.

This is by far the most common use of NextJump.
Generate JITted code sexp digest directly rather than from string.
Make Node implement List<Node> to avoid making one-element lists.
Eliminate some Java 5 iteration of AST node lists.

Java 5 iteration along hot or boot paths causes a lot of transient
iterator objects to be created. This patch removes some such cases
that appear to be along hot paths or paths hit heavily at boot.
Efficient arity-specific paths for constructing List<Node>.
For very large case/when, spill when bodies into JVM methods.

Many Ruby libraries use very large case/when statements. For
example, generated parsers, such as the one in whitequark/parser.
These large cases often do not JIT on JRuby because their JITed
size exceeds the bytecode size limits of the JVM. Some may compile
but then optimize poorly because the JVM decides it is a "huge"
method that's not worth optimizing.

This patch adds a configurable knob compile.outline.casecount that
specifies a count of cases (when bodies) in a case above which the
bodies will be emitted into their own JVM methods and
single-method optimizations are disabled. Currently this threshold
is set to 50 cases, but this is a somewhat arbitrary estimate
based on the roughly 30-50 bytes of bytecode required just for
the when matcher logic. 50 * 50 = 2500 bytes just for matching,
and then the when bodies are usually much more code.
Fix bad tracing test exposed by recent in-class method name fix.
Revert "Make Node implement List<Node> to avoid making one-element lists."

This reverts commit 0ae2a78b0598c8a31fa12cf8d51a6edf2d902bc5.

Several nodes implement ListNode add(Node) which conflicts with
boolean add(T) from java.util.List.
Merge branch 'securerandom' into jruby-1_7
Fix some coercion problems with new SecureRandom logic.
Move SecureRandom.uuid to native code.

All recent changes together appear to result in a 4-6x faster uuid
compared to 1.7.10. This and the changes for #hex should help
improve raw request throughput on frameworks like Rails that use
them heavily.
Top self ("main") should inspect to "main". Fixes #1410.
Incorporate ByteList snapshot that is slightly more robust.

See jruby/bytelist#3.
add MRI ffi specs

last failing currently