Now that TTreeReader reads them correctly.
This fixes ROOT-9559.

In case the friend tree/chain has not been added manually after
reading the TTree, but it comes automatically from information saved
to file, chain.GetListOfFriends() returns a nullptr while
chain.GetTree()->GetListOfFriends() correctly returns that TTree's list
of friends as per the information on file.
More discussion at https://github.com/root-project/root/issues/6741.

This fixes the RDF part of #6741.

...if gDebug > 0.

- try harder to find branches and leaves users requested when
  trying to figure out their type
- when building the list of valid column names, use the output of
  TBranch::GetFullName instead of the names (joined by dots) of
  the branches we traversed so far. With multiple nested
  TBranchElements, the traversal might be `a.b.c` while the name
  returned by TBranch::GetFullName (which is what TTree::GetBranch
  recognizes) might be simply `a.c` (see e.g. ROOT-9975).

These changes fix ROOT-9975, although in some corner cases they might
change which column names RDataFrame considers valid (any "reasonable"
user application that was working should keep working -- no tutorial,
test or integration benchmark we have was broken by these changes).

This fixes ROOT-9977, "[DF] SaveGraph produces an empty graph"

* Avoid calling TTree::ChangeFile if file is TMemFile

* Add regression tests in TBufferMerger and dataframe_snapshot

* [docs] Update documentation in TTree::Fill and TTree::ChangeFile

* Avoid triggering TTree::ChangeFile mechanism in RDF Snapshot

Create new RAII struct to store and change the value of TTree::GetMaxTreeSize, use it in RLoopManager::Run. Revert when issue #6640 will be closed.

This prevents certain ugly error messages in case an exception is
thrown during a multi-thread event loop: before this patch, in that
case the thread's slot number was never returned to the RSlotStack
and it could result in some misleading error messages being printed on
screen.

RDataSource event loops did not check whether Ranges had been exhausted
and always looped until the end of the dataset in all cases.
Event processing was a no-op after Ranges had been exhausted so results
were correct but runtimes were longer than necessary.

This fixes #6455.

* Dont check the pool size but number of slots
* Fixes the issue with EnableThreadSafety called but without
  EnableImplicitMT, which falsely triggered the assert

* Protect global state for to-be-jitted code shared across multiple RDFs
* Make global counter in RDefineBase an atomic
* Make RCsvDS thread safe by declaring globals static const
* Point out in the docs that ROOT::RDF::SaveGraph is not thread-safe

This is to be consistent with RAction and in analogy with the
naming of the corresponding init method InitSlot.

Before this commit, RDataSource columns were treated like a special
kind of Defined columns: they were registered in RBookedCustomColumn
and their contents were accessed via RCustomColumn::Get.

This commit removes the logic that was Define'ing ad-hoc columns
corresponding to the RDS columns. Instead, we store the RDS column value
pointers in a dedicated std::map and teach RDSColumnReader to directly
use that. Logic is simpler, we avoid an extra function call and an extra
copy upon data-source value accesses, and we move closer to implementing
column readers specialized for a given RDS implementation.

The new column readers bring two main advantages:
- logical branching has been reduced (for now, at the cost of introducing a
  virtual call)
- the new design makes it simpler to insert datasource-specific column
  readers

Before this patch, in cases in which t.GetBranch("a.b") and
t.GetBranch("b") both returned a valid address, RDataFrame was adding
only "a.b" to the list of valid TTree columns.
With this patch, both "a.b" and "b" are recognized as valid column names.

We need this change in behavior to avoid a _worse_ change in behavior,
described in detail in ROOT-10942: since ROOT-10702 was fixed,
TTree::GetBranch became more powerful and started returning non-null
addresses for branch names with form "a.b" while it was returning a
nullptr until v6.20/06. With RDataFrame's previous logic, this in turn
meant that valid code that was using "a" as a column broke as RDataFrame
was now adding the "a.b" spelling to the list of valid columns instead.

This fixes the RDF-related part of ROOT-10942: "a" is recognized as a
valid spelling again, and "a.b" is kept as a new valid spelling.

FindBranch deals with full branch names more nicely. This fixes RDF
not being able to find the "i.x" branch in ROOT-10702.

...and simplify function signatures accordingly.

Before this patch, if a RLoopManager went out of scope before running
its event loop (a rare occurrence, but indeed possible, especially in
interactive sessions), we were leaking certain weak_ptrs and shared_ptrs
to components of the computation graph, that were meant to be used by
lazily jitted code that was never actually jitted in the end.

With this change, when _any_ RLoopManager runs the event loop, we
trigger execution of _all_ jitted code that was registered, even if
it was registered by an RLoopManager that is now out of scope. In the
latter case, the code only performs clean-up of the heap-allocated
weak_ptrs and shared_ptrs and exits. We still "leak" in the odd case
in which RDF jitted code is registered but the application never actually
triggers any RDF event loops, in which case the code to be lazily jitted
remains in the pipeline until the end of the application, and parts of
the computation graph are kept alive indefinitely by heap-allocated shared_ptrs.

We now declare everything to the interpreter upfront, no need for the
facilities to lazily declare things to the interpreter via RLoopManager.

This should reduce the time required by jitting dramatically
in many common scenarios, as we do not need a different template
specialization of types that are expensive to instantiate for each
Define or Filter expression.

In the future, we want separate computation graphs to share and re-use already
jitted lambdas. Without this patch, however, we would have an ordering
problem or a redefinition problem, because RDF2 might want to re-use/redefine
a lambda that RDF1 is _going to_ declare, but (since we delay all
jitting to right before an RDF's event loop) that might happen too late
for RDF2.

With this change, all RDFs can jit all code that has been booked by all
other RDFs, resolving that problem. In addition, making fewer but "fatter"
calls to the interpreter is a performance optimization in itself.

...and add a test. This fixes ROOT-10346.

At construction time, RDataFrame sets its number of processing slots
equal to ROOT::GetImplicitMTPoolSize(). We always want to
construct TTreeProcessorMT's thread pool with a size equal to
RDF::GetNSlots().

Besides being more robust (less reliance on shared global state),
this patch guarantees that if the number of threads in the thread pool
is different than what RDF requests, we get a warning from TThreadExecutor.

This is to fix ROOT-10549.

Even if something within the event loop throws, we still need to call
CleanUpTask to make sure SnapshotHelperMT::FinalizeTask gets called,
to avoid teardown issues due to input and output TTrees of a Snapshot
being deleted concurrently.