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]
[Truffle] Merge from Graal.
Another dump of too much editing to lose in new instr encoding
New instr encoder impl'd but not hooked up yet
[Truffle] Remove ObjectSpace tests - no way to dynamically turn OS on or off in JRuby, and enable continuation tests.
[Truffle] Add spec:truffle Ant target, and add to the Travis matrix.
use latest tesla to generate pom.xml
[skip ci]
[IR] Additional cleanup + generalization of unboxing pass.

* Cleaned up unboxing analysis a bit more by removing hardcoded
  assumptions about float-type unboxing. Should be easier to add
  unboxing for additional types in the future.

* Added ability to store booleans in "unboxed form" for use in
  branches without calling isTrue/isFalse on boxed ruby values.

  For the interpreter, we continue to use "boxed booleans" since
  they are cached one-time true/false objects to prevent
  proliferation of temp-var arrays in the interpreter loop.

* More rubyspecs now pass with unboxing turned on -- still several
  failures that need working through.
[IR] Deleted unneeded opcodes.
[IR] Committing missing file.

* Third time I am doing this same mistake now.
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.