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()
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.
Clean up commented asserts

They are not too useful for debugging, and they don't express any
useful invariants either.
Merge pull request #772 from makortel/kdtree

Reco improvements -- Performance improvement in KDTreeLinkerAlgo<T>