The need for this was hidden by the fact the files were not closed (see
previous patch)

In ROOT that yields a TString. Without TString it would not even compile.

`Define` now returns the same node it is called on rather than a new
node of the functional graph.
This is a performance optimization as it removes the need to traverse
these nodes during the event loop, e.g. when checking filters in a
functional chain.

Behaviour is unchanged (except for `Define`s return type, which should
never be explicitly typed out by users anyway) and users can keep
treating `Define` _as if_ it returned a new node of the functional
graph.

In particular, now the rule is enforced that nodes in a certain branch
of the functional graph can only use custom columns previously defined
in _that_ branch.

TLoopManager keeps track of all custom columns that have been defined,
nodes and TInterface can query TLoopManager for that info.
A lot of logic is not needed in the nodes anymore.

TLoopManager now maintains a vector of names of defined columns.
The other nodes ask this list to TLoopManager rather than using their
own. The next commits will remove this logic from the other nodes
altogether.

The ctor of GSLMCIntegrator creates GSLRngWrapper instance on the heap and calls Allocate() member function which in turn allocates memory for GSL random number generator via gsl_rng_alloc(). When GSLMCIntegrator instance goes out of scope, its dtor is invoked which deletes the GSLRngWrapper pointer and thus invokes its dtor as well. However, ~GSLRngWrapper() frees the allocated memory only if fOwn pointer is set to true, which is only set in assigment operator, but not in the Allocate() member function. Therefore, the GSLMCIntegrator is leaking memory. This poses a problem, when doing large number of integrations inside a for loop. The leak was discovered by running valgrind and inspecting the code.

now we can deal with thread safety in presence of several transactions
being treated.

Error in <TStatusBitsChecker>: In TProofPlayer class hierarchy, there are duplicates bits:
Error in <TStatusBitsChecker>:    Bit  16 used in TProofPlayer as kIsProcessing
Error in <TStatusBitsChecker>:    Bit  16 used in TVirtualProofPlayer as kIsSubmerger

Error in <TStatusBitsChecker>: In TProofServ class hierarchy, there are duplicates bits:
Error in <TStatusBitsChecker>:    Bit  16 used in TProofServ as kHighMemory
Error in <TStatusBitsChecker>:    Bit  16 used in TApplication as kDefaultApplication

frexp ultimately give the same information (what power of 2 is this number) but is 3 times faster
than the pair (log2, nearbyint).

  TStatusBitsChecker::Check and TStatusBitsChecker::CheckAllClasses will
   determine if the set of "status bit" declared in the class and its
   base classes presents any overlap.  The status bit are declared in
   a given class by declaring an enum type named EStatusBits.
   If some of the duplication is intentional, those duplication can
   be registered in an enum type named EStatusBitsDupExceptions.

   ~~~ {.cpp}
   // TStreamerElement status bits
   enum EStatusBits {
      kHasRange     = BIT(6),
      kCache        = BIT(9),
      kRepeat       = BIT(10),
      kRead         = BIT(11),
      kWrite        = BIT(12),
      kDoNotDelete  = BIT(13),
      kWholeObject  = BIT(14)
   };

   enum class EStatusBitsDupExceptions {
      // This bit duplicates TObject::kInvalidObject. As the semantic of kDoNotDelete is a persistent,
      // we can not change its value without breaking forward compatibility.
      // Furthermore, TObject::kInvalidObject and its semantic is not (and should not be)
      // used in TStreamerElement
      kDoNotDelete  = TStreamerElement::kDoNotDelete,

      // This bit duplicates TObject::kCannotPick. As the semantic of kHasRange is a persistent,
      // we can not change its value without breaking forward compatibility.
      // Furthermore, TObject::kCannotPick and its semantic is not (and should not be)
      // used in TStreamerElement
      kHasRange = TStreamerElement::kHasRange
   };
  ~~~ {.cpp}

  Without the EStatusBitsDupExceptions enum you would see

  ~~~ {.cpp}
TStatusBitsChecker::Check("TStreamerElement");

Error in <TStatusBitsChecker>: In TStreamerElement class hierarchy, there are duplicates bits:
Error in <TStatusBitsChecker>:    Bit   6 used in TStreamerElement as kHasRange
Error in <TStatusBitsChecker>:    Bit   6 used in TObject as kCannotPick
Error in <TStatusBitsChecker>:    Bit  13 used in TStreamerElement as kDoNotDelete
Error in <TStatusBitsChecker>:    Bit  13 used in TObject as kInvalidObject
  ~~~ {.cpp}

This specially named Enum will allow to annotate the EStatusBits enum to list
the bit that are intentionally/knowingly duplicated other bits in the clas
hierarchy

It was conflicting with TObject::kCanDelete.

Even-though it is persistent information, it is only ever used when first creating the branch
and thus changing the value should have not practical down-side.

It was conflicting with TApplication::kDefaultApplication.  This are used transiently so no backward
compatibility issues

The value conflicted with TLeaf::kNewValue.

The value conflicted with TBranch::kBranchObject.

This allows for automatic checking overlaps in a given class hierarchy.