compiler: Make all values convertable to <unit>

The motivation behind this is to allow procedures that return values to
be passed as procedure types returning <unit>. This allows the
procedure's value to be safely discarded. This complicates the planning
for (eqv?) with #!unit but that is such a corner case that support can
be removed.

This is analogous to how any expression in Scala can be cast to Unit to
discard the value
runtime: Remove confusing VectorCell::fromElements

There is an unused VectorCell::fromElements() builder that attempts to
take ownership of the std::vector data. Since the pointer is actually
owned by the passed std::vector this is incorrect. This builder is
unused so just remove it completely

Also add a Doxygen comment for the remaining ::fromElements() to be
clear that it expects to take ownership
compiler: Proper (*for-each) support

Previously (for-each) and (vector-for-each) were implemented as aliases
for (map) and (vector-map) respectively. This had a number of downsides:

- Lambdas returning multiple values could not be passed to (*for-each)
  as the value was being used to build a temporary result. This problem
  was much worse for a potential (string-for-each) implementation as it
  would require the lambda to return a char

- It's possible to accidentally depending on the return value from
  (for-each) and (map) which is unspecified by R7RS

- We waste resources building and discarding an unused result value

Fix this by moving the mapping implementation to map.cpp and abstracting
away the mapping core logic for each type. New entry points are defined
for the (*for-each) functions that take a lambda returning <void> and
don't return a result value.

This isn't completely optimal for (*for-each) as we still build and GC
root an output vector while iterating over the input collection.
However, for lists and strings we can avoid the (potentially expensive)
construction of the final value.
stdlib: Rename list helper functions

Internal C++ functions use lowerCamelCase while external symbols are
undercore_separated
runtime: Fix two buffer overruns in StringCell

::copy() and ::fromUnicodeChars() were both attempting to NULL terminate
past the end of the UTF-8 data they were producing. This is a leftover
from when strings contained an implicit NULL terminator.
stdlib: Implement (substring), (string-copy)

(substring) is a direct wrapper around StringCell::copy(). (string-copy)
is implemented as a slicing procedure on top of (substring)
stdlib: Implement (string-{up,down,fold}case)

These are equivalent to (string-map) using the character conversion
procedures but much more efficient due to the C++ implementation.
runtime: Fix stack depth when visiting long lists

Have our cell visitor use goto to forcibly tail recurse in visitCell().
This prevents long lists from causing deep stacks and possible crashes
when the GC is entered.
runtime: Switch cellvisitor to templated functions

Instead of using std::function use a function type template for the cell
visitor function. This allows the compiler to do more aggressive
inlining and intraprocedural optimisation. In release builds this speeds
up the garbage collector by at least 20% and removes 20KiB from the
static library.

This also removes the dumpReachableFrom code which was never used beyond
the initial GC development. A replacement would probably work better as
a helper procedure exposed to Scheme where it could print, filter, etc
itself.