At event-loop time we will already have the list of clusters of entries,
and we will be able to generate thread-local chains more efficiently, or
even switch to thread-local trees if we can/wish to.

it is not necessary to deserialise the streamerinfos and interact with the
type system if we did all this work already. This is visible for example when
opening and closing several small files through a TChain in a MT environment.
With this fix we keep track of the blob of bytes representing streamer info records
that we read and in case a blob has been already processed, no work is carried out.
The hash function used is sha256, therefore collisions do not take place.

this helper is in the ROOT::Internal namespace. The hash used is sha256
through the ROOT::Internal::RSha256Hash class.
Even if this is technically a container, it's not in core/cont because of
dependency issues: we do not want core to depend thread and viceversa.

the code of the class as well as the implementation of the hashing is
standalone and platform independent (no external such as openssl is
required).
The rationale is to have an easy way to transform in hashes blobs of
bytes.

This is perfomant than caching identifiers, more extensive to
experiments, and code is simpler.

Try to iterate through libraies until we will find a mangled_name;
If found, we just break and start from there next time.

In previous allmodules&autoloading patch, we used callback from
DeserializationListener to get Decl and loaded corresponding libraries.
It worked, but the performance was bad because ROOT was loading
excessive libraries.

In this patch, we use TCling::LazyFunctionCreatorAutoloadForModule. This
function gets callback when "mangled_name" was not found in loaded
libraries thus we have to the load corresponding library and lookup
again.

I used unordered_map to store mangled identifier and library pair. I'm
doing an optimization by hashing mangled name and storing library not by
name but by uint8 and hold uint8-name information in another vector.
Also tried std::map but unorderd_map was more performant. There are
better hash table like:
https://probablydance.com/2018/05/28/a-new-fast-hash-table-in-response-to-googles-new-fast-hash-table/
we can try to use them if this part gets crucial.

With this patch:
```
Processing tutorials/hsimple.C...
hsimple   : Real Time =   0.04 seconds Cpu Time =   0.03 seconds
(TFile *) 0x562b37a14fe0
Processing /home/yuka/CERN/ROOT/memory.C...
cpu  time = 0.362307 seconds
sys  time = 0.039741 seconds
res  memory = 278.215 Mbytes
vir  memory = 448.973 Mbytes
```

W/o this patch:
```
Processing tutorials/hsimple.C...
hsimple   : Real Time =   0.08 seconds Cpu Time =   0.07 seconds
(TFile *) 0x5563018a1d30
Processing /home/yuka/CERN/ROOT/memory.C...
cpu  time = 1.524314 seconds
sys  time = 0.157075 seconds
res  memory = 546.867 Mbytes
vir  memory = 895.184 Mbytes
```

So it improves time by 4x times and memory by 2x.

Harmonise "auto"  as suggested here: https://root-forum.cern.ch/t/harmonise-auto-and-auto-in-the-tutorials/29202

Removing obsolete code from TFile(compression algorithm and level of StreamerInfo should the same as in TFile)

The test merging histogram with labels, which have been filled using SetBinContent() and ResetStats to compute the entry, fails in older ROOT versions

Fix the protected function Th1::IsEmpty used in TH1Merger for the case when both fTSumw=0 and fEntries=0, but in reality the bin contents are not zero.
Add in this case a check to all bin contents, including underflow/overflows
Fix also TH1::GetStats() for the case of labels histograms.  In this case when you have   fTSumw=0  and fEntries !=0 (for example after calling SetBinContent) you want to compute
the correct fTsumw and fTsumw2 values

This reverts commit 52a910dc.

Fix correct name for Standard/reference architecture

These functions (enabled when -ffast-math is used) were only added
in glibc 2.15. However, SLC 6 still uses glibc 2.12 and clang does
not check before emitting the symbols, so linkage with clang is
broken when fast math is enabled.