Suppress format warnings caused by python headers.
Protect against recursive definitions (for example,

data members of a type we're already priting - either static data member or "cross-references").
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
10.9 fix: copy constructor of std::map is explicit there...
Add support for secondary groups (ROOT-4126)
Port previous patch on MacOsX
Fix way the path name is passed to cache handling functions
Keep at most 1 old session logs by default
Use transparency
Move opaque
No longer hide the compiler detail.

The partial desugaring (part of normalization) now strips a typedef
even when it original from std and points to compiler details (__gnu_cxx, etc.).

The cost of this convenience was the fact the same entity could have different
'name' and thus different class even-though they were supposed to be strictly
equivalent. i.e. depending on the way to get to the class it could be name
vector<int*>::iterator or __gnu_cxx::iterator<int*> or std::iterator<int*>.

This different from the case where we have a strictly bidirectional equivalent
between the class and its unique typedef (yes, we are talking about you std::string).

This also different from the case where there is a semantic difference between
the two possible name.  I.e. where an opaque typedef is used.  For example,
vector<Double32_t> and vector<double> and where the 'way' to get to the type[name]
is relevant.
Preliminary support for template alias.

GetPartiallyDesaguredType now desugar template alias
but does not yet properly propagate the opaque typedef
and thus:

  template <typename T> using myvector = std::vector<T>;
  myvector<Double32_t> vd32d;

  template<class T> using ptr = T*;
  ptr<Double32_t> p3;

Both currently result in the Double32_t being ignored.
Implement “Move Opaque”, when “can edit histograms” is on.
Fix stressMathCore (broken because of bogus classnames)

Rollback also some functionality for the manipulation of template
arguments via dict selection file.
Only arguments which are not template specialisations can be
treated.
Remove ifdefs depending on the usage of c++11
Avoid polluting the global namespace with typedefs
Remove thread safety solution for the TNormalizedContext

it is of course crucial to have a thread safe ROOT. On the other
hand it may be premature to impose such an ad hoc solution
for this particular problem.
An improved design could maybe avoid the need of a synchronisation
mechanism altoghether in this case.
Relax a bit the 80 cols limit in TMetaUtils

it is indeed not a requirement of ROOT and could have in some
cases geopardised the clarity of the code.
Implement (finally) correct transparency stipple filling on Windows
Remove unreferenced local variable