`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.

Before only condition value==floor(value) was checked.
But it can be tru also for very large floats or doubles.
Up to certain limit it does not make sence.
Moreover, it can produce wrong output while value large 1e200 cannot be
stored at all

This fixes that regex characters in the source directory path
cause the CMake configuration to fail with cryptic error messages.

This happens because we interpret the source directory as a regex in a
few places in our CMake code.

This is a preparation because we want to ship module configuration
files in the future in the cling resource directory (Clang VFS overlay
files and modulemaps). This means that we will need to know this path
in a few other places (e.g. where we specify the -ivfsoverlayPATH
arguments and potential -fmodule-map-file=PATH args)

It also makes this giant function a bit easier on the eyes.