Allow completely empty input to be parsed correctly

Node
- default value for the lines array issued by prelude

Tests
- addition of a new test

Close #16
Implementation of a multiservice

Mode
- creation of the multiservice method
- conversion of the "validate" method to the new pattern

Code
- creation of a cache mechanism that prevents the execution of a service in case it has been executed on the same source code

Validation visitor
- code to perform the validation of the graph with the extraction of errors and warnings has been moved to this dedicated class

Partial fix of issue #50
Possibility to provide multiple change sets to update the source

Code
- update method can also receive an array of changes
Added a binary definition to be able to build the package easily.

I also refactored the code around a little.

## Package definition (package.json)

- added a binary definition, to launch a build of the package
- removed the unnecessary file extensions in the commands specified in `scripts` section, for simpler code

## Documentation

- documented the usage of the new command (binary) to launch the build of the package
- simplified the installation procedure which was too formal

## Binaries

- added the binary in charge of running the build of the package, for now it is completely equivalent to the usage of the build script

## Scripts

Refactored scripts for a better design:

- we keep actual scripts at the root, and put helpers/libraries in `node_modules`
- scripts all export an `exec` function, in case they want to be reused in some way, and they run this main function when they are directly invoked through Node.js

The grammar builder has also been cleaned, with clearer code, especially to manage paths, which is the most tricky part of it.

Closes #56
Addition of the extension information on the parsed resource

This commit introduces the possibility to specify an extension for the resource that has to be parsed. This extension is given as argument to the parser so that it can produce the correct tree according to the file extension. This way, .tpl and .tml files can be parsed with the same grammar.

* AT-HTML grammar
Addition change of the root statement validation according to the file extension.

* Code
When an instance of Code is created, the extension is provided as argument.

* Tests
Addition to tests and possibility to specify the extension of the content to test.
Improved the build binary by interacting with the user.

Now the build tells when it finished, and if it was with success or not.
Mainly updated the grammars regarding the latest version of PEG.js.

# Updated dependencies in package definition

- for safety, I precised the main versions of the libraries used
- the dependency for PEG.js is not over GitHub anymore, since they released a new version in npm

The update to the latest PEG.js version required some changes in the grammars.

# Prepared support for alternative parsers

- improved the grammar builder function to be able to build several parsers per mode
- in AT-HTML mode, made the validator common to all parsers, by moving it a level up: it makes more sense and can be available for alternative parsers

Also, it's now the NodeInstancier instance which gives access to the Node class in the grammars, so that it could be made configurable at instancier creation.

# Other

- I also removed some old useless files by the way.
- I updated the duration limit of a test which was always failing on my machine (the performance impact is not big)
Added benchmarks.

A new utility has been created in tests, in order to run benchmarks.

This utility relies on a benchmarking library, and mainly takes care of getting the inputs and displaying the results.

For now it can use two benchmarking libraries:

- the renowned benchmark.js library
- a custom one developed internally, to have more control on how to benchmark and get significant results

It uses the second by default.

Here are the changes that have been done along with that:

- added npm script definition tun run the benchmarks
- added development dependencies for testing, mainly benchmarking
- added inputs to benchmark the parsers HTML and AT-HTML
Optimized a lot the parsers.

# Line and column removal

No more call to line() and column() PEG.js methods are made from the parsers: they were detected as being too expensive.

This implied changing some things in the implementation:

- in the Node class and more generally node module, use of lines and columns have been commented
- in the web application, the annotations put to the editors for validation were using the line and column information: we now use the Ace API to compute them from the index information instead

Tests have also been updated, since the resulting graph doesn't contain anymore the line and column information, so they must be removed from the expected results specifications.

# Node optimization

The Node class is defined using the OOP library, which can provide nice features in terms of API. Unfortunately, one of these features was really expensive, and impacted the construction of the nodes: when you build an average of 20,000 nodes for a HTML file of 1500 lines, the overhead becomes monstruous. However there is a gain even for smaller files, and for every parser since it's related to Node only.

There is now a ligther Node implementation, which modifies only a few things: mainly for node creation, but also for node insertion.

In order not to copy code, a full refactoring has been made:

- there is now a dedicated folder for the whole `node` module
- class definitions have been split into files
- the two nodes implementations share a common base definition for their classes

Finally, and this is something important for this to be used: the NodeInstancier now gets an options at its creation, to choose which node implementation to use.

So now, the grammars use a NodeInstancier instance configured to use the light Node implementation.

# IMPORTANT change in the AT-HTML parser build

Now the AT-HTML parser is built using the PEG.js option `cache` set to `true`. It can make the parser slower as written in the documentation, but it resolved the issue of the parser never finishing parsing some inputs (so what they say in the documentation is true).

Thus I:

- enabled more inputs for benchmarks as now they work, and in acceptable time
- changed a timeout limit in the test of a rule for AT-HTML (maybe slower because if the activated option)
v0.1.0