Balltree's node_data radii seems to be incorrect

### Describe the bug

The node data from constructing a BallTree seems to be incorrect. Each parent node's radius should always be greater than or equal to both its child's radiuses, since the radius is that of the smallest hypersphere containing all the points within that node, and the children of a node is just a subset of that node. Therefore if a child's radius is higher than its parents, it could just adopt the hypersphere of its parent as its current sphere to have a smaller radius.

That being said, I did some testing internally and it is very common for either or both children of a node in a BallTree to have a higher radius than their parent! Can someone point out what I might be doing wrong here, or is the BallTree radius simply an approximation? I don't think it is either, since we see [here](https://github.com/scikit-learn/scikit-learn/blob/main/sklearn/neighbors/_ball_tree.pyx#L92) that the radius of a node is computed as the largest distance from its centroid (mean of all its vectors) to any vector within the node. 

Edit: I think I understand why child nodes could potentially have a larger radius than their parent, due to the fact that we use a new centroid based on the points within a node each time (instead of comparing to the parent centroid). It's possible that we end up using a worse centroid which nets a larger radius. However, I still think the radius calculation is off - see my follow up comment below.

### Steps/Code to Reproduce
```
from sklearn.neighbors import BallTree    
import numpy as np

np.random.seed(3)
Z = np.random.random((1000, 512)) 
model = BallTree(Z, leaf_size=1, metric='l2')
(
    _,
    idx_array,
    node_data,
    _,
) = model.get_arrays()

root = node_data[0]
lchild = node_data[1]
rchild = node_data[2]

_, _, _, root_radius = root
_, _, _, left_radius = lchild
_, _, _, right_radius = rchild


if left_radius > root_radius:
    print(left_radius, root_radius)
if right_radius > root_radius:
    print(right_radius, root_radius)
```

### Expected Results

Nothing should be printed.

### Actual Results

`6.93039685892859 6.923245275411173`


### Versions

```shell
System:
    python: 3.8.12 (default, Oct 12 2021, 06:23:56)  [Clang 10.0.0 ]
executable: /opt/miniconda3/envs/models/bin/python
   machine: macOS-10.16-x86_64-i386-64bit

Python dependencies:
          pip: 21.2.4
   setuptools: 62.1.0
      sklearn: 0.24.2
        numpy: 1.20.3
        scipy: 1.7.1
       Cython: 0.29.24
       pandas: 1.1.5
   matplotlib: 3.4.2
       joblib: 1.0.0
threadpoolctl: 3.1.0

Built with OpenMP: True
```

COMMENT:
Second example incorrectly computing mean -- variable `distances` has shape `(512, )`, which is number of dimensions, not number of vectors. Changing in `linalg.norm` parameter `axis` from 0 to 1 yields close enough result (for all 16382 nodes in that particular example difference less than `1e-14`).

For every node algorithm first selects axis with largest spread of data among it and after that splits vectors in two new nodes by median value on that axis. Wikipedia article states that radius should be equal to distance between split-vector and farthest vector from it. But there is a [modification](https://www.cs.cornell.edu/courses/cs4780/2018fa/lectures/lecturenote16.html) (algorithm at the page's bottom). Ignoring part with selecting axis from randomly sampled points, look at line 10 -- keep node's ball center not at the median, but at the mean. It actually make sense, as it's lowering ball's volume thus leading to possibly less queries. And it's working exactly as expected, as long as node splits done via median. And that's the algorithm implemented in code.

While having a strange feature (node radius can be bigger than it's parent) it's correct.

Labels: module:neighbors, Needs Investigation