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.)
Added StringOffset.

The StringOffset type is added to allow string indexing be done in O(1)
instead of O(N), because UTF-8 and UTF-16 are variable-length encoding.
Added all Oz modules