Implement the "templ arg swallowing": ROOT-5672 (aka Reflex::Selection)

The goal of these changes is to allow entities like:
myVector<class T, class alloc = myAllocator<T>>
to aquire the normalized name
myVector<class T>
if the selection file / ROOT::Meta::Selection namespace instruct
the system to do so, i.e. to "swallow" a number of template arguments
if they have a value identical to the default.

In order to achieve this goal, several changes had to be developed in
different chapters.
1) Consolidation & Simplification
 - Special property names, like name, iotypename, nArgsToSkip, do not
   appear anymore as strings in the code, but their values are centralised
   in TMetaUtils.
 - Some constructs were expressed using or counting on it C++11. For
   example initialiser lists, range based loops, return of big objects
   by value.
 - Further factorisation and extraction of common routines in TMetaUtils.

2) Interface Changes & Thread Safety:
 - TInterpreter::RegisterModule: it now takes a vector of string-int
   pairs in order to be able to attach to template declarations (in
   the strings) a number of template arguments to keep.
 - TNormalizedContext: now contains a table of template declarations
   pointers and integers. This information is used from within the
   GetNormalizedName routine (which preserve its interface).
   The read and write access to this table, implemented as a static map
   (faster than an unordered_map for small sizes - linear VS const
   time), is thread safe. This is done in order to support simultaneous
   dictionary loading and name normalization. This is achieved with
   an extremely lightweight spinlock based on std::atomic_flag.
   It is expected that this code path, accessing this map, is not
   systematically followed (for example for non-template classes).
   A possible improvement could be represented by the usage of an
   atomic mechanism to protect the map pointer.
   Indeed, for every bunch of insertions which potentially happen at
   library load, one could envisage a reallocation of the map and a
   replacement of the pointer by this new one (many reads, a few writes
   - the spinlock approach treats reads and writes symmetrically).

3) Dictionary generation:
 - The Scanner now fills the template class ptr - int map in the
   TNormalizedContext for the dictionary generation phase.
 - rootcling now manages the construction in code of the map of
   fwd declarations - int. This happens concretely, for historical
   reasons within the TModuleGenerator. Somehow, rootcling manages
   the migration of the information in TNormalizedContext at
   dictionaty creation time to the ROOT runtime (as everything else,
   by the way :-) )

4) TMetautils routines:
 - The code added to TMetaUtils is composed by a main routine, KeepNParams,
   and othe useful but ancillary functions.
 - KeepNParams is able, recursively, to build a new QualType with the right
   number of template arguments. To achieve this goal it follows in parallel
   the template arguments of the actual template instantiation (which are
   QualTypes) and the parameters of the template (which are decls). It correctly
   treats also non-type template arguments (integers). It makes sure that,
   based on the maximum number of arguments to keep, the new type contains
   the "right" template arguments, for example skipping the ones for which
   the argument is equal to the default parameter.

5) New Tools and experimentation:
 - For the newly developed components and for the most recently added, C++11
   was used.
 - Clang-format was used to comply to the ROOT coding rules (at least the ones
   that can be respected only lexing).

6) Documentation:
 - All the algorithms are documented.
 - The new feature is documented in doxy style in the header
   DictSelectionReader.h