Switch to ScalaTest 2.0

This required no code changes as we weren't using deprecated APIs
Implement (vector-append)

This is a trivial wrapper around BoxedVector::fromAppended()
Include the source location in our AST, SST

This is used for more informative error messages. We don't currently
pass this past the expression tree due to conflicts with the upcoming
codegen refactor. We also don't track the expansion location inside of
the expaneded macros; I don't have a good idea what the best way to
track and display those locations are yet.
Clean up application extraction

Previously syntax and primitives were implemented by expanding an
et.VarRef from their symbol and then looking inside the et.VarRef in
extractApplication.  The problem is only StorageLocations are truly
variable and can be referenced outside of the fiction of the frontend.
Referencing syntax or primitives as values is nonsensical but et.VarRef
had to allow it to simulate their application.

Clean up by changing extractApplication to extractSymbolApplication
which takes a scoped symbol and looks up its bound value. This can
handle syntax, primitives and storage locations. If there is instead a
nested expression in the procedure position that expression will be
recursively extracted and the et.Apply manually built without help from
extractSymbolApplication.  Because it's not possible to use syntax
or primitives as expressions the nested resolution case does not need to
handle them.

Clean up et.VarRef to only take a StorageLocation which cleans up the
expression tree for non-frontend users

Finally, fix unit tests that were abusing using primitives as
expressions. Add two new tests to verify that syntax and expressions
cannot be used as expressions.
Make character names case-sensitive

The final R7RS requires them to be case sensitive unless the parser is
in case folding mode. This can't be tested at the moment because we
don't properly error when an alphabetic character is followed by more
alphabetic characters (e.g. #\NEWLINE is parsed as #\N EWLINE).
Fix the name of (scheme write)

The name was copied and pasted from (scheme inexact) which made it
unloadable
Make ExpressionTree.toString a bit more readable

- Use the variable names when referencing storage locations. Report
  procedures are & while normal variables are $

- Make the et.Apply a bit more Scheme-y by putting the procedure at the
  head of the operand list

- Use Scheme quoting syntax for literals instead of et.Literal(foo)
Make SchemeFunctionalTestRunner fail with stderr

Previously only the generic "Execution unexpectedly failed" message was
used. However, if it failed due to a _lliby_fatal there's likely
descriptive message and possibly a representation of an irritant.

Directly use stderr as our failure message if it's not empty.
Fix converting a boxed datum to an abstract type

This manifested as it being impossible to convert a boxed datum to a
list element. This was due to a bogus test in BoxedLiveValue when
determining which type conversions were possible

- Make bt.BoxedType.directSubtypes a Set. The order of the subtypes is
  not significant

- Add bt.BoxedType.concreteTypes which recursively determines which
  possible concrete types a boxed type can have. For concrete types this
  simply returns the type itself.

- Switch BoxedLiveValue to do set comparisons between the possible types
  of the boxed value and the concrete types of target value. This seems
  to be more intuitively correct

- Convert the remaining users of subtypes to concreteTypes as they were
  effectively open coding the concreteTypes logic

- Remove the now unused BoxedType.subtypes
Feature complete quasiquotation support

This handles quasiquotion based on a few premises:

- Only (scheme base) procedures can be used. It would be nice to have both a
  (lists->vector) and a version of (list) that can return a constant list.
  However, it seems overkill to micro-optimize quasiquotion by introducing
  custom runtime procedures at this point

- Quasiquoted lists and vectors without unquoting should be represented
  "for free" as literals

- The number of procedure applications should be minimized

To implement this the expander first does a pass to build "segments". A
segment is either completely constant (ConstantSegment), composed of
expressions (DynamicSegment) or a procedure returning a list
(SplicedSegment, used to implement splicing). The only thing that can create
a new segment is splicing which will terminate the previous segment and start
building a new one.

If an unquoted expression is encountered while building a ConstantSegment it
will be converted to a DynamicSegment where the previous constants are
represented with et.Literal. If a quoted datum is encountered while building
a DynamicSegment it will be added directly as an et.Literal

After building the segments they are converted to the target collection type
using the abstract helper methods createConstantLiteral, createFromList and
createFromElements. These are implemented in the concrete subclasses
ListQuasiquotationExpander and VectorQuasiquotationExpander.

There are a number of special cases that try to minimize the number of
procedure applications required to expand the quasiquotation. The fallback
case simply converts every segment to a list, appends them to a final list,
and then calls createFromList
Properly handle \\ in string literals

- Include \\ in stringEscapePattern so the parser knows it doesn't
  terminate the string

- Use Regex.quoteReplacement in unescapeString. Otherwise the
  replacement "\" is interpreted as a lone escape character and the
  replacement aborts.

- Add unit tests for both \\ and \|