This optimization allows AsString to skip doing the dynamic call
to `to_s` when the target object is a natural String. It does not
currently work in refined scopes, like most indy method caching,
which makes this an optimization-in-waiting since AsString is only
used for possibly-refined code.

This reduces the bytecode emitted for DynamicScope variable
accesses by doing the following:

* The depth and location are embedded into an indy call site
  rather than being pushed and passed every time.
* The nil retrieval is done as part of the site to reduce the
  entire operation to two pushes and an invokedynamic.

This does not have much affect on methods that do not contain
blocks or eval, since they will use JVM local variables. Methods
that contain blocks improve by not emitting the location when
accessing variables beyond the 10th in scope. Blocks improve by
not emitting depth push, location (beyond 10th in scope), nor nil
retrieval calls.

Starting with an empty string saves us that initial bytelist and
byte[] allocation, but it is immediately made moot when we append
the first element of the compound string. This commit instead
starts with the compound string estimated size.

We have always pushed both the receiver object and the caller
object for all calls in the JIT, due to normal non-functional
calls needing the caller to check visibility. However this is a
wasted load for functional dispatches that do not check
visibility. Removing this unused argument shrinks all functional
calls by one ALOAD bytecode.

Code like `a, b, c = 1` can be compiled as assigning 1 to a and
nil to b and c, without creating an intermediate array. This skips
any call to `to_ary` which we may need to guard for, but altering
that method for any literal types will break most Ruby code. We
could also insert a builtin check here and only do the to_ary if
it might have unknown side effects.

The logic for ivar get and set did some extra stack gymnastics to
avoid evaluating the target object twice. However, all known cases
will have the target object either be literally `self` or a local
variable containing an inlined `self`. Since these cases can all
copy propagate, we can reevaluate them safely and avoid having to
introduce a temporary variable or juggle the stack around.

This also allows calling the VariableAccessor methods directly,
since the stack order now matches without manipulation.

Indy mode just does all this inside the call site.

* When the static components are FrozenString, emit as such to
  avoid allocating a new ByteList every time.
* Construct the bufferString from scratch every time, so we can
  properly right-size the buffer. The previous code used a cached
  ByteList of the appropriate size, but since it was shared any
  modification immediately caused it to reallocate as a too-small
  string.

These changes roughly double the performance of a string like
"foo#{$$}bar" in a simple benchmark on OpenJDK 19.

This eliminates one load of a boolean value for splats of the form
[*ary].

This appears to only be used by the inliner.