Remove those comparing unsigned with signed warnings.
Introduced nchar as to be easier to change the internal string type.

There is also a bunch of u"...", but they can be easily modified by a
sed script to u8"..." (UTF-8) or U"..." (UTF-32).
Introduced the macro MOZART_STR for Unicode string literals.

Instead of writing u"hello", one should now write
MOZART_STR("hello"). That macro prepends the correct prefix
depending on the type of nchar (char, char16_t or char32_t).

The idea of this commit belongs to Kenny TM~.
Added test case for Atoms.
Test case: created mozart::MozartTest.

New test fixtures shall inherit from MozartTest instead of testing::Test
directly to:

1. Automatically set up the VM
2. Use some common EXPECT_ methods, including:
    - EXPECT_IS<Type> - test if a node has some specific type
    - EXPECT_EQ_INT   - test if a node is an integer with given value
    - EXPECT_EQ_FLOAT - test if a node is a float with given value
    - EXPECT_EQ_ATOM  - test if a node is an atom with given value
    - EXPECT_PROCEED  - test if the OpResult is proceed
    - EXPECT_RAISE    - test if the OpResult is raise with given label
Some Unicode utilities.

Introduction of the LString<C> type, which is a length-prefixed
string of character type C. This is used in many cases where only a
pointer to the null-terminated string is inefficient/insufficient.
LString is used extensively in the utf.hh header.

Added operations to:

 * Convert between different UTF encodings
 * Compare two UTF strings
 * Count number of code points in a UTF string
 * Decode/encode Unicode strings from/to byte-strings.

Reviewed by S. Doeraene.
Compare atoms by code points instead of raw bytes.

The compare() method in AtomImpl is replaced by compareByCodePoint().
char_traits<>::compare() work in code-unit-based comparison. This will
produce a different ordering than code-point-based comparison when
UTF-16 is used, e.g. "\U00010000" is encoded to [0xd800, 0xdc00], which
is lexicographically less than [0xffff], so we get the non-sensual order
"\U00010000" < "\U0000ffff".

(Of course, this does not consider collation (e.g. "ö" < "p" in some
locale) or normalization (e.g. "á" == "a\u0301"). They should be
provided by separate functions for those who wants to treat
human-readable strings.)
Added exception helpers for Unicode errors.
Added the String data type.
Added the VirtualString interface.
Added the ByteString datatype.
Rewritten the LString class to better reflect the instance's lifetime.

The LString class has been enriched with lifetime information. This caused
the class to split into 3 types.

1. The LString class, which assumes GC or permanent lifetime. This LString
   is similar to before, which has a 'string' and 'length' field. The
   content will be destroyed after GC, so this class should only be used
   when associated with a node.
2. The ContainedLString class, which has self-maintained lifetime. Instance
   of this type will have a standard C++ container (be it std::string or
   std::vector) associated, in addition to 'string' and 'length'. The
   content is valid as long as the instance is valid.
3. The BaseLString class, which is the superclass of the above. It assumes
   temporary lifetime.

A ContainedLString cannot be safely object-sliced to a BaseLString.

The LString and BaseLString exposed in the mozart namespace are immutable.
To obtain a mutable type, use mut::LString or mut::BaseLString.

Added a bunch of convenient methods to LString to simplify its common
usages.

-----

Combined the two bool fields of coders to an enum bitfield. This also
reserve the opportunity to introduce even more options to the coders.

-----

Migrated ozListForEach from boostenv/main to vm/main. The signature is a
bit different though. Also, included function_traits to reduce the need of
manually supplying some template parameters, when it can be deduced from a
function object (mainly used in newLString and ozListForEach.)
Added function isLeadingCodeUnit and reviewed codePointCount.

Before codePointCount had 3 overloads. Now it is templated over
the character type instead.
Added methods sliceByCodePointsFrom and -FromTo.
Added many operations on String and ByteString.

* Merged interfaces StringLike and ByteStringLike as StringLike
* Adopted array indexing for String and ByteString through Dottable
* Other methods (append, search, hasPrefix, etc.)
Fixed: SpaceRef was not listed in MemWord small types.
Slight performance gain in checking for speculative bindings.
Fixed several GR bugs.
Clean up.
Removed make<T>() and hid other dangerous operations.

StableNode::make<T>() and RichNode::remake<T>() were too dangerous,
because their name did not imply that there was a 'become'
operation hidden inside. So they were removed. For consistency,
UnstableNode::make<T>() has also be removed.

To keep efficiency, while adding more type safety, I added new
overloads of copy(), init() and reinit() that take an
UnstableNode&&. These methods simply copy the inner Node. They can
be called, e.g., with T::build(...) as parameter.

Following the same spirit, Self::reinit() has been renamed as
become(). It makes very clear that this is the rightful 'become'
operation.

RichNode::reinit() has been made private. It can only be called by
become(), and some selected algorithms that play with the inners
of nodes anyway: GC, SC and unification (for temporary bindings).

So, for general purpose code, only the following is left:

* T::build() to create a node,
* init() to initialize a StableNode or an UnstableNode
  (with efficient implementation when given an Unstable&&),
* copy() to copy into an UnstableNode,
* Self::become(), to allow a data type to change *itself*
  (the fact that it is in Self prevents code that is external to
  the data type from playing around with become).