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

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

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.

and allows to manage implicit multithreading.

This will allow the parallel execution of void returning functions

There is not a single method to be exposed to the user