Keep track of true alloc size in StringLikeCell

Currently we never reallocate when shrinking a string and always
reallocate when growing a string. This can lead to pathological
behaviour when repeatedly changing characters that have different UTF-8
encoding lengths than the character they're replacing.

There's only 16 bits free in StringLikeCell which is insufficient to
store the actual allocation size. Instead store the unsigned delta
between the byteCount (+ implicit NULL byte) and the actual allocation
size. This field is called allocSlackBytes.

When we allocate or reallocate a string round its size up to the next 8
byte boundary. This is intentially conservative as Scheme encourages
immutable strings and even when mutation is possible it must preserve
the character count. This means most strings will never exceed their
initial allocation size. Using 8 bytes will cause no wastage on either
Mac OS X 10.9 or glibc 2.17 on amd64.

Constant strings created by codegen and all symbols always have a slack
of 0 as they're immutable.

We reallocate a string if shrinking it would cause more than 16KiB
(MaximumAllocationSlack) of memory to be unused. This also ensures the
slack bytes count will always fit in to allocSlackBytes.
Add support for eqv?

This leaves one failure for procedures which might technically be
allowed by R7RS but highlights our poor handling of boxing procedures.
It also should have a test for symbols creating using (string->symbol)
which is not implemented yet.

These shortcomings will hopefully be addressed in the next commits.
Add ps.StoreEmptyClosure

This stores a procedure cell with an empty closure using constant data
instead of a cons allocation. This provides a few benefits:

- No runtime GC overhead for boxing closureless procedures

- Multiple constant cells can be merged together by LLVM. This
  especially helps before we have a box/unbox merging pass but it will
  be even useful later as it can merge procedure cells boxed in
  completely different code paths.

- The constant cell of 24 bytes is likely smaller than the code required
  to build and allocate it at runtime depending on the architecture
Make StringCell::copy const

It should not modify the original string
Remove stale comment in boolean.cpp

boolean=? is defined to take a list of boolean so it's an error to
invoke it with non-boolean arguments
Mark _lliby_fatal is [[noreturn]]

This has two advantages for C++ callers:

- It can allow for better code generation in some cases

- IT will suppress "control can reach end of non-void function" warnings
  if it's the last line in a function returning a value
Implement symbol stdlib procedures

This implements symbol?, symbol=?, string->symbol, symbol->string
Fix a comment referring to wrong Clang version

This code has not been tested with Clang 3.4
Fix eqv? unit tests without constant merging

- Instead of defining a variable then reassigning it to two other
  variables use (let). This ensures they're in the same storage
  location.

- Add a clause to isEqv() that checks for closureless procedures with
  the same entry point. This fixes closureless procedures boxed in
  different locations not being considered eqv?

- Add an additional test for native functions which catches the above
  boxing mistake
Implement eq? as eqv?

eq? can nearly be implemented as a pointer comparison except identical
symbols may have different instances if (string->symbol) is used or
constant merging is disabled. The symbol implementation could be changed
in the future if a fast eq? is required
Implement equal?

This should be fully R7RS compliant. However, there are no tests for
bytevectors yet because there is no way to construct non-constant
bytevectors
Fix test name

The test was referring to (append) while (vector-append) was being
tested.
Fix the return value of vector-ref

It's defined to return <vector-cell> when it should really be
<datum-cell>. Add a unit test to ensure at least procedures can be
returned from (vector-ref)
Partial bytevector library support

This adds bytevector?, make-bytevector, bytevector, bytevector-length,
bytevector-u8-ref, bytevector-u8-set! and byyevector-append
Implement (apply)

This also fixes a problem where procedure trampolines would accept extra
arguments to procedures not taking rest args
Remove UTF-8 strngs as a value type

This is completely unused by the stdlib as it uses StringCell to cache
important data about the string and allow for NULL bytes mid-string. The
current implementation is only useful for NFI but has some shortcomings.
Namely, the UTF-8 C string is not kept in sync with the boxed
representation. For example, the following would print "123":

; Set str to a UTF-8 C string containing "123"
(define str (nfi-function-returning-123-cstring))
; This will implicitly copy the UTF-8 C string to a new string cell
(string-set! str 1 #\x)
; This will implicitly copy the original string, not the modified one
(write str)

The solution is to remove UTF-8 C string support and depend on bindings
to convert back and forth. In the future explicit NFI helpers can be
provided to convert back and forth, similar to the plan with record
types.
Reword confusing comment
Fix confuxing typo

Change scala => native. "Scalar" was the old name for "native" but the
typo wasn't caught in the search and replace.
Add CellType.schemeName and ValueType.schemeName

This will be used to improve value conversion error messages to include
the human-readable type name.
Persist REPL history to disk

This uses the builtin jline support for file-based history to store the
REPL history in ~/.llambda/repl-history. This should make REPL based
experimentation much less annoying, especially when llambda recompiles
are required