Reorganize KDTree data structure for improved CPU performance

Half-way SoA solution, use separate vectors to store Node structs and
the data, and an index to refer to the current node. By construction,
the index of the left child is always current+1, therefore we don't
have to store it.

We can exploit the fact that the dimension where the split of leaf
nodes is done alternates from tree depth N to N+1. For each depth it
is enough to store only the median (1 float) of the contained leaf
nodes of the current dimension instead of the bounding box of the the
leaves (4 floats). The search can be accommodated to this change by
giving the search box as 4 floats, and alternating the min/max of the
current/other dimension in each recSearch() call. Although
addSubTree() can no longer be utilized, the smaller data structure and
the reduction of comparisons (=branches) in recSearch() lead to
noticeable performance improvement.

The Node.right field, which stores the index of the right child, can
be abused to contain the information of whether the current node is
leaf or not (smallest valid value of right child index is 2). The
Node.right field can be further exploited to store the active
dimension of the current tree depth (0 or 1).
Use bit-wise & instead of logical && in the innermost point-in-rectangle check
Reorganize KDTree data structure even further, change search interface

Employ Structure-of-Arrays. This implies an interface change,
i.e. vector of only DATA can be returned (instead of
KDTreeNodeInfo<DATA>). Returning only vector<DATA> would be faster
also without the SoA data structure modification. In all uses of
KDTree I found (including the non-templated one in
RecoParticleFlow/PFProducer), the coordinates of the found items are
not used.

With SoA the data structure can be compacted a bit by storing the
coordinate of the current dimension for leaf nodes in the same array
where the median is stored for intermediate nodes.
Use std::nth_element to partially sort the input vector

std::nth_element appears to be slightly faster than the hand-written
Wirth algorithm.
Remove partly the recursion in recSearch()

The recursion in cases only one child node will be accessed can be
easily transformed to iteration, which is somewhat faster. When both
children need to be accessed, it is probably better to keep the
recursion, as some kind of stack would be needed anyway.
Fix compilation error in MultiHitGeneratorFromChi2.cc

Knock-on of KDTreeLinkerAlgo::search() interface change in aa10920.
Remove obsolete unneeded code
Add some comments to recSearch()
add consumes interface
add consumes interface
Revert "Use std::nth_element to partially sort the input vector"

This reverts commit b3d6503d3b235e05d2eee6b71111c7e3eea76178.

The results of seeding changed in a subtle way in the commit. If the
elements can have equal coordinates (in either or both dimensions),
the "Wirth algorithm" and std::nth_element sort the vector in
different order, leading to different order of nodes in the tree, and
different order of values returned by the kdtree search. If the
algorithm using the kdtree search is sensitive to the order of values,
results may change.
Fix a subtle bug in recSearch()

If the elements can have identical coordinate (in either or both
dimensions), the right sub-tree/child node can have elements with
coordinate equal to dimCurrMax. This should be rather rare though.
fix FixMatrixInjector required after changes in reqMgr 0.9.79   https://twiki.cern.ch/twiki/bin/viewauth/CMS/DMWMReleaseNotesReqMgrTestbed; acknowledgements to Alan Malta Rodrigues
Made OtherThingAlgorithm independent of edm::Event

By decoupling OtherThingAlgorithm from edm::Event allows us to test different ways of getting the data from the Event.
Also got rid of the header for OtherThingProducer
Changed name of accessor which allows external items to change BranchIDLists
Added comments describing what an algorithm is doing
Added tests for Refs formed from alias branches defined in a previous process.

A bug was discovered in the interaction between edm::Ref and EDAlias. The bug depends on the exact order between the original and alias branch names and/or branchIDs. The additional tests cause the bug to manifest. The change to the original test to create Refs in step2 is there to catch any possible regressions.
Fixed bug between edm::Refs and EDAlias

Nulling out the BranchID for a kept EDAlias some times caused edm::Ref’s created in subsequent jobs which refer to the aliased branch to fail. The failure depends on the exact ordering (branch name and/or branch ID) between the original branch and the alias.
no longer needed
change args from pass by value to pass by const reference