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

Hid GetWP()
Moved GetPoolManager() to the ROOT namespace.
Made the constructor private.
Renamed GetNThreads to GetPoolSize()

TScheduler -> TPoolManager. Renames and changes completely its
implementation.

Tested that won't interfere with previous instantiations of tbb, for
example other frameworks with an instance of the tbb scheduler already
running when loading ROOT.

Solves conflicting behaviours between classes depending on tbb.

See more here: https://indico.cern.ch/event/607814/contributions/2466931/attachments/1409778/2155811/TScheduler.pdf

this optimisation can become relevant when the model is built via a copy constructor.