Allow NearestNeighbor radius_neighbors to accept an array for the `radius` keyword argument

### Describe the workflow you want to enable

In KDTree and BallTree, there is a way to pass in a radius array that queries nearest-neighbors for each sample point for different radii.

- BallTree: https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree.query_radius
- KDTree: https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree.query_radius

However, in `NearestNeighbors` class, the https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NearestNeighbors.html#sklearn.neighbors.NearestNeighbors.radius_neighbors function only allows a single radius. 

In my current application, I am first computing the distance to the say Kth nearest-neighbor, `R` for each sample point in some space, and then for each sample point, computing the number of neighbors within that radius in some other spaces:

```
neigh = NearestNeighbors(
        n_neighbors=k,
        algorithm=algorithm,
        metric=metric,
        n_jobs=n_jobs
    ).fit(dists)

dists, _ = neigh.kneighbors()
radius_per_sample = dists[:, -1]

# compute on the subspace of XZ
 xz_data = np.hstack((X, Z))
 neigh = compute_nn(
        xz_data, algorithm=algorithm, metric='forest', k=knn_here, n_jobs=n_jobs)

# here, though I have to loop over each sample
for idx in range(n_samples):
        num_nn = neigh.radius_neighbors(radius=radius_per_sample[idx])

# If I repeat this multiple times across different subspaces, it is a bit cumbersome
```

### Describe your proposed solution

Allow `radius` parameter in `NearestNeighbors.radius_neighbors` to be an array of shape `(n_samples,)`, which would have a similar functionality as the KDTree and BallTree.

Presumably, this would be possible for BruteForce as well, although maybe computationally more expensive.

### Describe alternatives you've considered, if relevant

Alternatively, I showed how users would loop through samples just to pass in a different radius. Since the API of KDTree and BallTree inherently have this ability, it seems natural to allow `radius` in `NearestNeighbors.radius_neighbors` to be an array.

### Additional context

I am happy to submit a PR if this is deemed relevant.

COMMENT:
As a workaround, you can precompute the neighbors graph with the maximum radius, then call `radius_neighbors` multiple times with each radius. Under the hood, `radius_neighbors` will filter the precomputed graph, which avoids recomputing the neighbors from scratch.

```py
import numpy as np
from sklearn.neighbors import RadiusNeighborsTransformer
from sklearn.neighbors import NearestNeighbors

# precompute the graph of nearest neighbors
X = np.array([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6]])
max_radius = 3
transformer = RadiusNeighborsTransformer(radius=max_radius)
X_graph = transformer.fit_transform(X)

# find the neighbors of each point, for different radii
nn = NearestNeighbors(metric="precomputed")
nn.fit(X_graph)
for radius in [1, 2, 3]:
    neigh_dist, neigh_ind = nn.radius_neighbors(radius=radius)
    print(neigh_ind)
```

Labels: New Feature