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.