They will never be seen and can never be mutated by a user.

This patch introduces a new indy call site for dynamic strings.
Instead of using frozen strings for the constant bits and doing
all construction and concatenation in the call-side bytecode, this
version embeds all constant strings into the indy call site and
passes the dynamic arguments only. This moves all concatenation
logic into the call site, where it can be specialized for small
arities or dumped into a generic large-arity string builder.

Note about consecutive static strings:

These probably should not happen, but due to the way we propagate
literal frozen strings it's possible to have multiple static
string pieces in a row. We will want to look at the optimizations
done in LocalOptimizationPass to re-calcuate the condensed set of
operands (combining consecutive string elements) to ensure we are
not wasting cycles on concatenating multiple static strings that
could be a single operation.

When the dynamic elements of a dstring are not trivially
appendable, we must dynamically dispatch to to_s to get a string
result back. However, we don't want to always dispatch to to_s, so
this patch introduces a marker interface Appendable that indicates
there is a fast path for appending certain core types. The indy
call site for dstring will bind each dynamic element to a type
check and branch to the to_s call if necessary, and then proceed
to append each element in turn, either as its Appendable form or
as its to_s result or, eventually, as an anyToString generic form.

This improves performance of dynamic strings containing non-
trivial dynamic elements that must be to_s'ed.

This patch also introduces a second less-specialized path for up
to 5 dynamic elements that avoids using an argument box. This
returns such cases back to the performance of the old non-indy
"pre-inlined" version of this logic and could possibly be expanded
to larger arities as long as the switch does not start to be a
bottleneck.

This can be expanded to cover more core types, but currently is
only implemented by String, Fixnum, Float, and Symbol.