When noting that a TStreamerInfo set has already been processed, we
must do it in 3 separates steps:
  - check it was seen before
  - read and process the set
  - record that the set as been seen.

The previous situation:
  - check and record that the set as been seen
  - read and process the set
led to a race condition if a second thread was checking the same
set before the second step was completed (in which case the
second thread was believing that the set was process and looking
for the result of the process (one of the StreamerInfo) but could
not find it.

We extend RConcurrentHashColl to have 2 new operations
  - standalone Hash calculation
  - standalone Find of hash
  - standalone Insert of hash.
and we use it to split the check and the recording as described
previously.

(this is an addendum to 95bf468438)

if the size is bigger than the default value. Document better the behaviour, too.

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.

Parallelized sum in node and boosting via update predictions loop in MethodBDT and various loops in LossFunctions.cxx

There are three different kinds of header files in Core:
  * C headers - they can be included in C contexts
  * Config headers - they are supposed to be textually included in each
    TU.
  * No RTTI C++ headers - they can be built in non-rtti context which is
    needed for stage1 builds.

The rest of the headers in Core require rtti in order to be built, either
because they use typeinfo or exceptions.

This patch structures the ROOT's special modules in that way allowing
implicit module builds to be trigger from the right complation. For
example, we cannot (and should not) trigger build of C++ module when
compiling C code.

The lock needs to be taken to be able to have a fixed state.
But then we want to rewind to the state just before this lock was taken.

Avoid to search 'again' for the thread local information (the reader count)
in the Unlock when we already did in the lock and we have good way to
pass it from one to the other (The LockGuard)

Prior to this update if a thread requested the write lock when another thread had two or more nested
read lock take, the code would dead-lock

Use a EStatusBits 'enum' instead of a 'constexpr static int' (allowing automatic checking for overlaps)

This reverts commit ef8888f6.
This commit broke tutorials/multicore/imt101_parTreeProcessing.C,
found with git bisect.

Compared to `GetAtSlotUnchecked`, `GetAtSlotRaw` trades some more
safety for some more performance: not only it avoids checking for
slot initialization (as `GetAtSlotUnchecked` does) but it also avoids
construction of a `shared_ptr`.

Reset() completely unlocks a locked mutex, returning a state object that allows a
subsequent call to Restore() to restore that state.

and don't create fake directories to store histograms.

There is no support for thread_local on macOS, so variables with
thread local storage must use the ROOT macros for this purpose.