First attempt of creating a fast parser.

- the fast parser has a first implementation
- a set of performance (benchmarking) tests are being put in place
- some little fixes in the normal parser have been made
Improved the fast parser architecture, integration and tests.

- externalized the node class definition from the fast parser module
- implemented a first version of the benchmark
- improved the grammar builder function to be able to build several parsers per mode
- added the fast parser to the compilation process
Completed and added benchmarks thanks to refactored benchmark code.

- moved benchmark from specific HTML mode folder to the generic test folder and refactored the benchmark engine to be able to run benchmarks on any parsers
- added npm script to launch the benchmarks
- added a benchmark for AT-HTML

Added a Fake Parser for HTML:

- uses the EXACT same grammar as the normal parser
- completely mocks the classes used by rules' actions, that is Node and NodeInstancier: they do NOTHING
- used to check the performance impact of the model classes, not the grammar-generated parser

Added a copy of the fast parser for HTML reusing the line and column functions of PEG.js. It is used to check their performance impact.
Added scenarios to benchmarks, with alternative implementations of current code.

# Alternative implementations

## Light Node

- added a light implementation of the Node, not making use of the OOP library in the constructor
- added an option to the NodeInstancier to choose between the light Node or the "normal" Node: by default the normal Node is used
- the NodeInstancier computes itself the end offset of the Node (as before) and thus doesn't forward the source to the Node, to avoid storing big strings (and maybe computing stuff from the source)
- it's now the NodeInstancier instance which gives access to the Node class in the grammars, since it changes regarding the given option
- for each mode (HTML & AT-HTML), added two parsers: one which doesn't call line() and column() methods, and another which does the same and moreover uses the light Node

## Simple Node

- added also an ULTRA simple implementation of Node and NodeInstancier, used by the HTML simple parser (another alternative - formerly called fast-parser)

## Empty Node

- added a Node Mock, which is a class which implements the required Node methods but with no-ops (or the minimum to make the grammar work, with fake properties)
- modified the HTML Fake Parser which now uses this node implementation (it was extracted from there)

# Node

- the use of column and line indexes is now removed (commented)

# AT-HTML

- made the validator common to all parsers, by moving it a level up

# Benchmarker / Benchmarks

- simplified the logged results
- added sample inputs to the benchmarks
Mainly changed the benchmark library behind.

- created a custom benchmark library
- modified the benchmarker to use my custom benchmark library
- updated benchmark helpers
Used browerify to test HTML parsers in the browser.

The HTML parsers have been processed by browserify, to be able to use them inside browsers. This is mainly for performances profiling.

An attempt is ongoing for the AT-HTML parsers, but there is a problem of transport configuration (I guess) when trying to use the ariatemplates nodejs package, for the validation of the graph.