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:
It also appears to me that the distance calculations seem to be incorrect. An example here:

```
from sklearn.neighbors import BallTree    
import numpy as np

np.random.seed(3)
Z = np.random.random((10000, 512)) 
model = BallTree(Z, leaf_size=1, metric='l2')
(
    _,
    idx_array_z,
    node_data_z,
    _,
) = model.get_arrays()

start_idx, end_idx, is_leaf, r = node_data_z[1100]
print(start_idx, end_idx, is_leaf, r)

# Calculate bound for hypersphere manually
node_vectors = Z[idx_array_z[start_idx:end_idx]]
nu = np.sum(node_vectors, axis=0) / (end_idx-start_idx)
distances = np.linalg.norm(node_vectors-nu, axis=0)
bound = np.max(distances)

print(bound)
```

This prints
```
751 761 0 6.587321409213497
1.1855915076710466
```

We get an sklearn calculated radius of 6.58, but by taking the furthest distance between the points and their center, we lower that bound to 1.185. 

In general, playing with the different nodes here, I find that the lower the balltree gets (the smaller the spheres), the more incorrect the radius gets compared to my brute forced bound. At very high levels, the balltree's radius estimate is tighter than my bound. What gives?

Labels: module:neighbors, Needs Investigation