Previously, array access were generated via a code transformation in
ArrayTransformation in xlang, where Array Select and Update were
wrapped in if-then-else with an Error in the else branch. They are
now natively supported in VC generation.  Some testcases --- that would
trigger bugs when --xlang is not used with functional array ---- are
included in this commit

The commit introduces a new abstraction to traverse Leon trees and collect
path conditions. This traverser is used for the implementation of the
VC generation for arrays.

- remove superfluous implementations doing almost the same
- introduce pre/post traversal and transformers as foreach/map/fold
- Redefine other operations exists, contains, as folds
- Fix freshenLocals bug found by Ravi

- 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

Solvers wrap solvers or factories, depending on the needs.
Factories no longer wrap factories, except for the special case of
timeoutsolverfactories (it does it in a typesafe way though).

Fix TupleRewrite with new posts, fix ScopeSimplified, Fix pretty printer

- We now explicitly create them from SolverFactories
- SolveSAT/solve/solveWithModel/etc.. is not only available through the
  SimpleSolverAPI() wrapper.o
- Remove mostly unused/useless solvers

- Debug sections can be toggled to enable detailled information
- Options can be explicitly turned off, --debug:options lists all
- Switch from multiple reporters to a single one to rule them all
- Turn cegis:gencalls on by default

- Search tree can be iterated over in order
- Worker pool get displayed periodically when stuck
- Make sure global caches are concurrent

- Activate through --cegis:vanuatoo
- Possibility to skip isomorphic models
- One pattern per conjunct

- Refactor code extraction
  - Standardize extractors
  - Fix type identification by resolving type aliases

- Redo reporter integration with Scalac
  - Fix relining to prevent bizarre compile-errors

- Refactor Pretty-Printers
  - Extensible class interface
  - Not returning mutable string-buffers anymore

- Fixes according to 2.10
    - 100% false warnings in Tests
    - imports for postfix-ops or implicits

- Upgrade ScalaZ3 to 2.10

- Upgrade Cafebabe to 2.10

- Choose expressions becomes uninterpreted functions under the same
  constraints.

- Fix bug with variablesOf considering choose binders as free.

- Silence evaluator errors when occuring with tentative lucky models.
  Note that choose expressions cannot be evaluated nor compiled.

Z3 may return an id->id model for array kinds, leading to an assertion
error caused by the expectation of getting an array literal. We
shortcircuit with z3IdToExpr to catch such cases for all kinds.

- 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

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.

CEGIS now support internal flags that can enable/disable its features:

1) Injecting Counter-Examples on top of the unsat core to drive the
   search to interesting areas. Does not help => disabled

2) Computing Unsat-Cores to strenghten the search of programs. Help in
   some cases, doesn't hurt much => enabled

3) Checking whether the formula is unsat without blockers, to unrolling
   when there is no chance of finding a solution. Does not help =>
   disable

4) Add support for function calls in CEGIS generators. This is disabled
   by default and can be enabled using --cegis:gencalls.

It seems that doing additional checks in 1) and 3) triggers FairZ3 to
unroll more, tempering with the performance of the solver.

Also, this implements some improvements in the resulting programs by
simplifying further expressions.

This commit also fixes a serious bug (that apparently affected no one in
purescala/Extractors, namely the reconstruction function for Let and
LetTuple was broken).

This commit also introduces new runtime checks when contructing
instances of LetTuple or TupleSelect, to ensure that types are correctly
set.

1) Implement inner-case-split heuristic, that distribute And(..,Or(),..)
in a case-split. It also pushes Not() inside the formula, so
Not(And(a,b)) becomes Or(Not(a), Not(b)) which is then handled by
inner-case-split.

2) Extend regular case-split to work with n-way ors. Or(a, .., m,n) gets
decomposed into a N-alternatives case-split.

Given solutions (Sa, .., Sm, Sn), it recomposes into:
    If(Sa.pre, Sa.term, If(.., If(Sm.pre, Sm.term, Sn.term)))

EmptySet, EmptyMap and SingletonMap are redundant, so they are removed.
They are subsumed by FiniteSet and FiniteMap.

This commit also deletes two testcases that were testing for equality
between EmptySet and FiniteSet of 0 element. Obviously they no longer
relevant. Additionnaly, this commit adds some new regression testcases for
Maps and Sets.