Implement printing expressions

Now it is possible to print an expression and get the result as a String
object. Parentheses are correctly handled because their count for each
expression is stored in the AST node.
Add a skeleton for expressions analysis

A class for analysis of expressions is added. Currently it contains only gaps
to be filled. Each gap is associated with a particular expression type. The
analysis is run for expressions in almost all types of statements and for
expressions used as parameters for generic components instantiations.
Refactor tags analysis

The method of tags analysis is changed significantly. Currently there is
a bijection between created tag declaration objects and different tag types
(except that there are no objects for invalid tag types). Previously, there
was a bijection between AST nodes of tag references and tag declaration
objects (object for a new tag reference overwrote the previous object
if present in the symbol table). Now the tag declaration object is updated
when necessary and not overwritten.

Moreover, the builder pattern is introduced to the tag declarations hierarchy,
contained in package:

pl.edu.mimuw.nesc.declaration.tag

In turn, the factory pattern is used for creating appropriate objects for
abstract tag references during the analysis of tags.
Fix a bug related to checking types of variables

Type definitions are now properly handled during the operation of checking
variables types.
Implement analysis of basic expressions

Analysis of the following types of expressions is added:
    * binary operators: + - * / % << >> <= >= < > == != & | ^ && ||
    * unary operators: + - ! ~
    * operators '_Alignof' and 'sizeof'
    * all types of literals
    * identifiers
Change the main POM to remove a warning

The POM is changed not to use versions of JUnit earlier than 4.11 that could be
used because of transitive dependencies.