Adds a benchmark with many cool magic tricks with bits.
However, proving some of them is very costly and we
could potentially look at opportunities to make the proofs
go through faster.

Leon now matches Scala semantics of Int as 32 bits bit-vectors.
This commits modifies the semantics of IntLiteral to be treated
as 32 bits integer everywhere (solver, evaluator, ...).

Introduces a new literal type, InfiniteIntegerLiteral, representing
a natural integer. The front-end maps the use of BigInt to these
new trees, and the solver properly handles them as mathematical
integers.

The behaviour of many regression tests changes due to this new
semantics. In particular many of them now timeout because they
are no longer proving properties over mathematical integers. This
commit updates the tests to reflect this new semantics.

FiniteArray now takes an Expr for the length, a default
Expr, and a Map of defined Expr for some of its elements.
Adapt the rest of Leon to the new trees.

The PrettyPrinter tries to be a little bit smart about
how to print the array, only printing a few elements when the
array gets too big. The regression test produces an
huge array counter-example that used to lead to a crash of
Leon with the previous implementation of Array (fully represented
in memory).

- evaluate it to simplest value
- solve it to arbitrary value
- Use within CEGLESS as bank of exprs
- Avoid GuidedCloser if non-det expr (contains choose, holes, ..)

Introduces terminates(f(..)) witnesses in the spec, used to generate
safe recursive calls.

After a split i.e. on a List with Cons, the witness becomes

terminates(f(.., Cons(h, t), ..))

at which point we know that calling f(.., t, ..) is safe
termination-wise.

This is necessary to allow expressions in tests, such as List.::

- Implement smt and smt-z3/smt-cvc4 as options for --solvers

- Uses a main solver sources for verification/CLP, taking into account
  --solvers

- Implement Z3-SMT sets

- Add tests for Z3-SMT

More precise tracing, especially for in-IDE exploration of execution

- Ensurings/Require are now proper purescala trees
- Introduce Assert as a tree
- Simplify tactics to support arbitrary asserts/errors/inner ensurings
- New phase to inject assertions for unsafe calls (array/map access)
- Refactor Default and Induction tactic

- NormalizationRule becomes priorities, so that we can have multiple
  distinct layers

- Use the @library annotation, move synthesis stuff to synthesis,
  Oracles.

- Make sure tests use PreprocessingPhase and import synthesis when
  adequate

- Extract proper package objects fix patternRecons and simplifiers

- Reorganize library:
  - leon.{choose,???} -> leon.lang.synthesis
  - leon.{waypoint,epsilon} -> leon.lang.xlang

- Holes become chooses

- Unhandled types are removed, Untyped is now checked for and
  a warning is issued if an untyped expression is found.

Methods:
--------

Methods are now supported in ADT roots only (e.g. single case classes or
abstract classes). The phase `MethodLifting` converts them to normal
global functions which makes them transparent to the rest of Leon.

Introducing Leon Library:
-------------------------

Common structures and functionalities can be shipped as part of the
Library.scala file, which is a set of ADTs with methods.

Imported via `import leon.Library._`

New Annotations:
----------------

- @verified means library function will not be considered for verification
  unless specifically given through --functions

- @proxy allows non-pure bodies, which will be silently ignored.
  pre/post need to be in purescala.

Functions without bodies (e.g. proxy methods) are now materialized with
a choose construct automatically, replicating the post-condition. This
allows compilation to bytecode and execution of VCs refering to proxy
methods.

Tree Modifications:
-------------------
- FunDef now have params, not args.

- VarDecl is renamed ValDef.

- Added methods in ClassDef, as well as This and MethodInvocation,
  both are converted to normal function calls by the MethodLifting
  phase.

- Calling functions are now typed, FunctionInvokation takes a
  TypedFunDef which is basically a FunDef with type parameters' values.
  Instantiation of types within the signature/body is done on demand
  through this wrapper class.

- Operations on ADTs are now taking a *ClassType instead of *ClassDef.
  Similarly, Case/AbstractClassType takes values for type parameters.

- Introduces a GenericValue tree for models targeting abstract types.
  e.g. foo[T](a: T, b: T) { a == b } ensuring (_) will find a model with
  { a -> T#1, b -> T#2 }

- Only "simple" hierarchies allowed with type parameters. All members of
  the hierarchy must define the same number of type parameters and
  correctly pass them to parent classes.

- Type parameters are invariant.

Refactor the TimeoutSolver and TimeoutAssumptionSolver so
that they no longer use innerCheck methods. We now only
create solver as subclassing Solver or IncrementalSolver and
implementing the interuptible trait, and we can turn them into
TimeoutSolver at instantiation time with a mixin.

- Simplify code generation by replacing CompilationEnvironment with a
  simple scope state.

- Support Choose construct in both evaluators.

- Introduce RecursiveEvaluator (renamed from Naive) and TracingEvaluator
  which tracks intermediate values as well.

- Introduce offset as well as ranged positions, extract all positions
  from trees. Try to propagate them as much as possible. Introduced
  .copiedFrom

- Remove dead-code, and improve TreeOps a bit.

- Introduce Pretty-printer arguments