Automated the installation of 3rd party libraries for the web application.

Now it fully uses Bower for that. The documentation has been updated accordingly.
Added several enhancements for development.

These features are mainly accessible from the npm scripts feature.

Here they are:

- watch: you can now launch a watch process to rebuild your grammars anytime you change them
- test: launches the tests with mocha
- build: builds the package. Actually only build the grammars for now.
- stop: sends the shutdown signal to the server

Documentation has been updated accordingly.

NB: for now grammars handled by the build and watch scripts are HTML and AT. But it's easy to add others by appending them in corresponding scripts.
Now it is possible to know inside the web application when the parser failed.

- fixed the update method of code, and now actually returns the update result to the client
- now an alert is displayed when the parser couldn't parse the source, until it can finally do it again
- enhanced code and documentation of the alert method, and made possible to disable the close button
Updated documentation.

I mainly removed backlog items, either done or moved to GitHub issues.

Some small things have been fixed too (typo, formatting, ...)

An architecture schema has been added, and you'll need to use https://www.draw.io/ to view it.
Mainly fixed and completed the AT grammar.

- updated the AT parser documentation
- fixed a little the test input for the parser

AT Grammar:

- block nodes are now flagged as "block"
- changed term "element" to "node": more generic, and consistent with HTML
- some unnecessary code/rules have been removed
- changed some precedence in rules for better accuracy and consistency too
- completed the terminals encapsulation in nodes for many rules
- fixed CDATA content parsing (made it optional)
- finished implementing the parsing of expressions (with modifiers)
- fixed some little quirks (like allowing spaces at wrong places, setting properties with nodes, ...)
Fixed the HTML grammar (& made it more consistent).

Tests and parser generation options have been updated accordingly.

Fixed:

- directive content definition: requiring at least one character to match the rule, as for the others following the same pattern
- made the content of CDATA optional
- added a rule to parse unquoted tag attributes: more correct, they don't eat special characters and match id specs

Consistency:

- inverted the use of terms "elements" and "nodes": they were completely misused
- moved the CDATA declaration above the other elements definition, to match the order defined in the alternative of "elements"
- removed several prefixes in node types: like "comment.opening" to "opening", you can do a small node traversal to find out it's an opening of a comment (here the type is more like a category, not a unique identifier)
- avoided some useless rules or duplication for guarded closes used for rules like comment content, CDATA content, ...
Added standard colors for stylesheet definition, plus visual emphasis of unparsed text.

These colors use HTML colors names (http://en.wikipedia.org/wiki/Web_colors), along with the aliases.

Unparsed text handling:

- highlighting HTML output in Mode now handles unparsed text (the visual result assumes the unparsed text is always at the end, but this is not the case, and anyway you will see all the text, maybe with a very weird highlighting sometimes)
- the Stylesheet class also handles it (even if it is a bad design, see  ariatemplates/editor-backend#6)
The HTML parser is now far more permissive.

(tests have been fixed accordingly)

Made it more permissive and stores errors in nodes (flag them as having errors and set a property with a single error or a list). Also fixed some issues by the way.

Also, some nodes are marked as possible orphans: we should be able to parse them as they are, but outside of the context of the parent they should be in.

Here is a summary of the flexibility of the new grammar:

- most elements can be left open. When I say "element", I mean essentially any rule in the grammar which has a form: opening, content, closing.
- generally the content of these same elements has been made optional, or at least some parts of these contents
- there are other kind of rules that have been transformed to have optional parts. For instance, the attribute of a tag: when the assignment operator is present we expect a value but it can be left without
- when there are rules with only alternatives: if no alternative can be determined (too few characters), it falls back to a let's say abstract/generic super elements

Also brought more consistency and made important things optional:

- forced closing tags to match the latest opening tag, considering the id
- made it possible to parse alone not matching closing tags, considered as "orphans"
Implementation of grammar for at-html