compiler: Support for minimal symbol equality

One possible usage of literal symbol types is the definition of adhoc
enumerations, for example:

(define-type codec (U 'us-ascii 'utf8 'utf16 'ucs4))

Previously to test individual members of the symbol union a full symbol
compare was required. This requires a potentially expensive runtime
call which in the worst case will compare the symbols byte-for-byte.

Instead, we can be a bit more clever. When testing if a symbol union
value is equal to a specific member symbol we can:

1) Load the byte length of the union value and test if it's equal to the
   length of the testing member.

2) Determine which union members have the same byte length as the
   testing member. If the length is unique we can just use the length
   test.

3) Otherwise, we can determine the first byte that differs from all of
   the other union members of the same length. We can then load that
   byte directly after the length check to detect the testing member.

Additionally, we can pass value range metadata to LLVM containing the
possible byte lengths and byte values we're loading. This allows it to
potentially emit insructions more efficient than a full value load and
compare.

This is implemented in a new PlanSymbolEquality function which
PlanTypeCheck and EquivalenceProcPlanner both use.
Switch full-test.sh to POSIX shell

We can replace the use of array with a simple function. This allows
full-test.sh to work properly on FreeBSD where bash is optional and
installs to /usr/local/bin
compiler: Better plan for constraining to literals

If a value has its type constrained to a literal type it can be
replaced with a constant of that type. This allows us to discard the
original value which reduces GC pressure and allows for better code
generation.

Previously only LiteralBooleanType supported this and it was broken for
boxed values (i.e. CellValue)

- Introduce IntermediateValue.fromLiteralType that will convert a
  literal type to a constant value representing that literal

- Add support for converting literal symbol types to constant symbols

- Have the relevant .withSchemeType implementations call fromLiteralType
  when literal types are encountered.