Starting work on issue #100
Added several items

- bool opEquals(ref const Int128 rhs) const
- bool opEquals(Int128 rhs) const
- size_t toHash()
- ref Int128 opAssign(Int128 rhs)
- void toString(scope void delegate(const(char)[]) sink, FormatSpec!char fmt) const
  with an implementation for %t, a debug print format specifier
Add opCmp to Int128

Added functionality to sign-extend negative numbers in the ctor.
Improved Int128.opCmp
Improve the testing of opEquals
First version of opCast
Base 10 string serialization and type conversion
Add base 10 serialization to toString
Change isneg to nf (i.e. negative flag)
Changed the encoding for the data store

The two words used to store the value are now encoded as shown below

    |---- high -----| |---- low ------|
     63 62.........0   63............0
     NF   MSB            LSB

The main change is that the Negative Flag now is only stored in
the high half and therefore the low half is unsigned arithmetic.

The implementation of opCast to numeric values is non-trivial and
so the following information will help document the thinking
behind its impelementation. Only the case of integral value are
documented as the floating point implementation is trivial.

The flow chart below shows the logic in determining how to convert
a value to the smaller result type T. The logic for both signed
and unsigned outputs are compared side-by-side. The double [NF MSB]
means the Negative Flag and the Most Significant Bits. '*' will
represent any value other than zero. The action means what action
is performed on the LSB.

         signed   unsigned
[1 0] =>  negate   negate
[1 *] =>  T.min    0
[0 0] =>  trim     trim
[0 *] =>  T.max    T.max

The flow chart shows that there is some nice symmetry here. Still,
differences do appear requiring more code than desired. The value in
the unsigned case for [1 *] is zero, which in reality is the minimum
of an unsigned number. The way negation is handled is tricky due to
the need to use a conversion function on the result. Both of these
factors make code reduction non-trivial.
Added a ctor that can take a value for low and high
Implement addition
Fix the double ctor
Implement neg - two's complement
Fix the ctor to allow const values
Implement subtraction
Separate the negative flag from the numerical data
Use adc to transfer the carry in addition
Implemented subtraction

Added two new constructors to make working with negative numbers
easier. Also simplified the code in the original two constructors.
Reorganize the instructions in addition