Add SharedByteArray

This the basis for out-of-line strings, symbols and bytevectors. It
allows safe, low-overhead copying of those values across threads.
runtime: Add workaround for Valgrind on Mac OS X

mmap() on valgrind 3.9.0 on Mac OS X 10.9 will return a nullptr on the
first call. This isn't disallowed but confuses the rest of the code that
treats nullptr as failure.
runtime: Implicit data sharing using byte arrays

Note: This does not have matching codegen support. Codegen is completely
broken by this change.

This makes strings, symbols and bytevectors use implicitly shared byte
arrays when copying or transmuting entire values. This probably only has
a marginal memory usage benefit for most programs but lays the
groundwork for implicit sharing between worlds which makes inter-world
communication potentially a lot cheaper.

Allowing bytevectors to implicitly share with symbols and strings means
that symbols and strings are no longer implicitly NULL terminated. This
simplified the code somewhat and allows an extra character to be stored
inline. However, it means an additional StringCell method will need to
be introduced to return NULL terminated strings (probably as a
SharedByteArray)
runtime: Add support for Valgrind with CTest

Running "ctest -D ExperimentalMemCheck" will now run the test programs
inside Valgrind. This isn't very useful on Mac OS X due to poor Valgrind
support but should be helpful on Linux
runtime: CMakeLists tweaks

- Only enable -Werror in release builds for better compatibility

- Clarify comments and group our C++11 support together
runtime: Change memcpy => memmove in StringCell

This was originally memmove until the "sameString" slow case was added.
The idea was that if the source and destination are different strings
it's safe to use memcpy. However "sameString" refers to the destination
string and the *pattern* - it's still possible for the source and
destination string to be the same with sameString == false.
runtime: Re-enable asynchronous finalization

This appears to be left over from the segmented heap work

- Split _LLIBY_CHECK_LEAKS out from _LLIBY_ALWAYS_GC. They're orthogonal
  and _LLIBY_CHECK_LEAKS has an orders of magnitude less overhead.

- If neither LLIBY_NO_ADDR_REUSE and _LIBBY_CHECK_LEAKS are defined then
  use asynchronous finalization
codegen: Support shared byte arrays

This is the codegen piece of the shared byte array support. This is
relatively straightforward - it simply prepends our existing constants
with the special "shared constant" refcount.
Merge branch 'sharedbytearray'
Remove stale references to et.Let

This is now known as et.Bind
Implement (zero?)

This is used in a lot of example code snippets in R7RS.
Add typedefs for StrongRef<> types

This makes typegen generate typedefs for each type of StrongRef, e.g.:

typedef StrongRef<DatumCell> DatumRef;
typedef StrongRefRange<DatumCell> DatumRefRange;

This cuts down on the verbosity of using strong references and makes the
code more readable. There is no functional change