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

Refactored the condition abduction code, refactored InSynth code out of Leon, and added the InSynth core library, with substantial amount of fixing and clearning sources, tests, and testcases

- 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

This fixes the classloader issue that we had, where, in codegen, a
library class would be loaded twice and be incompatible with itself.

It also fixes an oversight in evaluating expressions, where the returned
ground term was sometimes untyped (typically: empty sets and the like).
We now copy the type of the (unevaluated) expression in such situations.

Evaluators now have a common interface, and need to be instantiated
before they can be used. This makes them more like solvers, and allows
us to switch between them completely transparently.

Evaluators should support `eval` and `compile`. The default
implementation for `compile` returns a closure that invokes `eval` each
time.

`eval` returns one of three results:
  - EvaluationSuccessful: evaluation terminated with a value
  - EvaluationFailure: evaluation resulted in a runtime error
  - EvaluationError: evaluation resulted in an internal error

CodeGenEvaluator is a drop-in substitute for DefaultEvaluator. It works
by compiling Leon methods to Java bytecode which is loaded dynamically.
The `compile` method should be used as much as possible, as `eval` will
recompile the expression each time (the functions from the Leon program
are always compiled only once, though). CodeGenEvaluator intercepts most
runtime errors and rewrites them into `EvaluationFailure` results.

Use --codegen to use code generation as the evaluator of choice within
FairZ3Solver. (Has no effect if neither --feelinglucky nor --checkmodels
is used.)

Improvements of EvaluatorsTests testing suite, and verification
regression suite is now run twice (with different options). As a result,
the original tests for codegen are obsolete.

- Recursive functions that manipulate only integers.
- "Smart conditionals" compilation scheme.