Use constructors/extractors everywhere (except solvers).
Eliminate any Tuples with <2 elements from Leon.
Deprecate rewriteTuples.
Rewrite FiniteLambda. Not necessarily better, just clearer.

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.

- 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, ..)

 - Some engineering fixes here and there
 - Make sure we remove witnesses before sending out to solver
 - Speed-up CEGIS:
   - Order tests based on likelihood to falsify input
   - Only assert wrongPrograms (C-Ex) when necessary

Introduces a guiding witness, indicating what the original solution was.
This original solution is then either

1) tried as potential solution (verification)
2) used as decomposition, for instance on If expressions.

- 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

- Free&Recreate solvers during synthesis. This avoids huge memory leaks
  due to Z3AST never being reclaimed thourough the entire synthesis
  process

- Add safeguard to catch Z3Solvers for which memory management is
  incomplete

- Describe individual rule applications to allow a user to select one
  in particular

- Scala-Printing LetDefs correctly, allow initial indenting

- Fix Choose with single out variable not generating Tuple1

- Give synthesis a specific path to follow, used by web

- Allow val (x: Int, y: Int) = ... along with locally{}

- Expose information on the synthesis search tree

- Correctly substitute varaibles in ADTInduction's pre/post

- Generic transformers with PC tracking, collect chooses with PC

- Detect line indentation of choose() to indent solution correctly

- Implement simplifier which renames ids based on the context

- Rescale timeouts, use uninterpreted solver for filtering simple cases

- Assume that choose() can reference the entire scope

  This is necessary to ensure that Lets do not get thrown away. For
  instance:

  Let(x = ..., choose(out => .. y ..))

  while the choose may not directly reference x in its preducate, it's
  part of its path condition and should be usable by synthesis.
  SimplifyLet should not simplify/replace it.

- Modify PC for Let(x, Fcall()), this probably needs to be generalized!

- Expose counter-example found during verification, include them in
  VCReport

- Decouple genVCs/checkVCs from Phase.run so that it can be used separately

Normalizing rules are rules that:
1) always help synthesis
2) are commutative
3) should be applied as early as possible

Here we apply normalizing rules explicitly before all other rules, and
in a deterministic order. This should dramatically reduce the search
space in cases where such rules apply.

Note that rules that are said to be normalizing should never fail once
instantiated.

EqualitySplit now is also applied if there is more than two inputs with
the same type.

InequalitySplit splits two integer inputs in the following way:
- a < b
- a == b
- a > b

Given x: T where T only have one inhabitant, CC(a, b), we generate a
subproblem with a,b as out variables, and x replaced with CC(a,b) in phi

This allows CostModels to estimate correctly the minimal cost of a
applying a rule.

With type information on the expected types of a solution
reconstruction, the cost model can provide dummy values of the correct
type, avoiding assertion errors when composing solutions.

The synthesizer used to generate wrong programs by generating inductive
programs with an impossible base-case. onSuccess on inductive rules now
prevents this by checking that sufficiently many cases have precondition
== true. Otherwise, onSuccess fails. This last-moment failure is now
handled correctly.

Strenghten precondition