Update the whole shebang to use the new core modules

Not only Theory, but also Task and Transformation 
do not need to depend on environment. Moreover,
we don't have to track the clone history in tasks.

The only thing we need to do, is to provide three
registration functions in Driver, namely:

  val register_transform : string -> (unit -> task_t) -> unit
  val register_transform_env : string -> (env -> task_t) -> unit
  val register_transform_clone : string -> (env -> clone -> task_t) -> unit

and then another three for task_list_t.

Then any particular transformation that is going to depend
on environment or clone_history, must register itself via
the appropriate registration function. It will be the
responsibility of Driver to recreate the transformation
for every new environment and/or clone history. It will
be easy, given that both [env] and [clone] are physically
comparable and provide a unique tag.

Thus, the generic interface provided by Transform can be
completely independent on [env] and [clone].

This commit implements the proposed interface of Task
and moves the environment stuff into a separate module.

The proposed architecture is as follows:

- Decl provides the type of declaration, decl, which is a sum
  of type_decl, logic_decl, ind_decl, and prop_decl. decl is 
  h-consed and does not depent on theory, context or anything else.

- Theory provides the types of theories and theories under construction.
  A theory is a list of (decl | use | clone) with namespace, and the set
  of known idents. Theories are not h-consed and they do not depend on
  env or task.

- Task provides the types of environment (env), clone maps (clone), and
  the task itself. It might be interesting to merge Transform with Task.
  An environment stays as it is today. A clone map is a private record 
  with the unique tag and physical equality. A task is essentially what
  context is today:
    
    task_decl  : decl               (* top declaration *)
    task_prev  : task option        (* the previous context *)
    task_known : (ident, decl) map  (* the set of known symbols *)
    task_clone : clone              (* the clone map *)
    task_env   : env                (* the environment *)
    task_tag   : int                (* the unique tag *)

  Tasks are h-consed. There is a guarantee that task_env and task_clone
  of task and task.task_prev are physically equal.

  Unless there is a good reason to do otherwise, the only way to produce
  a task is by split_goal, which takes a theory (and optionally a number
  of goals in it) and creates a list of tasks. Note that sharing IS LOST
  whenever two goals are separated by a clone instruction. However, the
  declarations will still be shared.

- Trasformation works on tasks, producing task lists, tasks, and alphas.

- use_export and clone_export may be allowed on tasks, rebuilding the
  whole task, whenever necessary.

This commit just adds the Decl module, but does not make anything use it.

dans les drivers il n'y a qu'une seul liste de transformations

 - Ajout de split_conjunction
 - Ajout du choix d'appliquer les transformations avant ou après la séparation
   en un but par contexte (certainement à modifier)
 - Ajout de quelques transformations et plugins
 - ajout des options list-printers et list-transforms

to build an ill-typed formula. Unsafe functions are actually unsafe.

- export everything to facilitate debugging output
- remove src/pretty.ml*
- restore output/why3.ml to register with Driver a printer from Pretty