Feature/language discretization

Now cell values stored by tracing the values the same way as in 2d:
the value is assigned to each node of the cell.

This is more consistent with the 2d format and allow to store data
in parallel without any kind of ordering.

- WriterModule now just contains calls to writers
- Add a WriterBase class to share cleanly common functionalities

Also improve VTKWriter functionalities
- the time series file (`.pvd`) is now produced and should be loaded
to get proper data

Finally add a GNUPlotWriter
- works for both 1D and 2D
- cannot mix node and cell data in the same result file (this is done
on purpose)
- A simple preamble describes the content of the file

Cell and node numbers are now added into the VTKWriter and not for all writers

The function `writeVTK` does not exist anymore. The syntax works now
has follows.
```
import scheme;
import mesh;
import math;
import writer;

let m: mesh, m = cartesian2dMesh((0,0),(1,1), (40,40));
let vtk: writer, vtk = vtk_writer("f", 0.01);

let rho0: R^2->R,   x -> x[0] + x[1];
let u0:   R^2->R^2, x -> (1,2);

let rho : Vh, rho = interpolate(m, P0(), rho0);
let u : Vh, u = interpolate(m, P0(), u0);

let time: R, time = 0; write(vtk, (name_output(rho, "rho"),
name_output(u, "u")), time);
```

Note that the second argument in the `vtk_writer` function is the time
period between two outputs.

It can now handle functions with values in B, N, Z, R, R^d and R^dxd

This allows for instance to retrieve completely the kind of P0
function that is in use. For instance a P0 function build of R^d
elements.

Outputs can now be handled pugs' scripts

Actually one needs to pass the discrete function and its name to the
writer method. With this commit one just checks that the given
functions are all defined on a same mesh.

This enforces coherency between data:
- the mesh
- the cell values defined on its connectivity

First tests with a crappy P0 functions