Merge pull request #153 from eregon/unpickle

Revert "Replace the boot unpickler by the real one from Pickle.oz"
Raise an error when small integer overflow happens.
Move Float methods to the FloatLike interface

* So not all numeric types must implement them.
* Not sure where divide (/) should be defined,
  but it only makes sense on floats so I went with moving it as well.
Implement Number.pow in Oz, so it calls the right multiplication operator

* This will make the transition to BigInt easier
* The code added in Number.oz is taken from Mozart 1
* I named the float power operator Pow (was fPow in Mozart 1)
Remove virtual from BoostBasedVM::newBigInt, it should not be overridden.
Start the foundations for big integers.

* Architecture: BigInt -> BigIntImplem (abstract, interface)
                       -> BoostBigInt (which will contain an actual boost multi precision integer).
* Using shared_ptr ensures automatic deallocation.
* The VM argument might not be needed in VirtualMachineEnvironment::newBigIntImplem
  but right now it is to raise an exception in the default VMEnv.
  That method should of course never be called in the default VMEnv
  (only from BigInt when we managed to call newBigInt()).
* We need to shrink BigInt to SmallInt.
Implement BigInt multiplication

* For now, using cpp_int for simplicity
Avoid creating two BoostBigInt when only one is possible.

* std::make_shared() will call the constructor,
  so pass a suitable argument for BoostBigInt constructors.
Make BoostBigInt::make_shared_ptr generic in its argument.
Ensure to not copy twice the BoostBigInt constructor mp_int argument.
The Boost Multiprecision library is new from Boost 1.53.0

* 1.53.0 was released on February 4th, 2013.
* We need it for big integers.
Implement BigInt::equals()
Implement BigInt addition
Add an helper for casting in BoostBigInt
Implement all BigInt operators!

* Many optimizations left and shrinking.
* Always coercing to BigIntImplem when an operand is not a nativeint.
Add a compare function with a nativeint
Shrink BigInt to SmallInt whenever possible
Use the pattern matching DSL to automatically waits for unbound values

* .is<T> is not waiting and returns false if the value is unbound at that time.
Make BigInt::shrink private.
Refactor the BigInt coercion by extracting a helper method