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

This allows us to use them in synthesis. Expose --solvers=..
option for synthesis.

- Implement the Leon Library in Leon-land rather than Scala-land.
  import leon.Utils._ becomes import leon.lang._
  import leon.Annotations._ becomes import leon.annontation._

  For now, the library defines generic Options and Lists.
  The library is automatically imported from the ./leon script, unless
  the --library=no option is passed.

- Support parsing of multiple files and modules.

- Introduce new annontations:
    @ignore: remove definition from Leon
    @verified: do not consider for verification unless explicitly
        specified

Use a datagen-based solver to find simple counter-examples. Note that
this solver returns Unknown most of the time, so it is best to combine
it with a full-fledged solver.

PortfolioSolver allows us to combine solvers and have them run in
parallel. The first result (!= Unknown) is used. Solvers can be selected
for verification using the --solvers option.

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.