Cloned estimators have identical randomness but different RNG instances

### Describe the bug

Cloned estimators have identical randomness but different RNG instances. According to documentation, it should be the other way around: different randomness but identical RNG instances.

Related #25395 

The User Guide [says](https://scikit-learn.org/stable/common_pitfalls.html#controlling-randomness):
> For an optimal robustness of cross-validation (CV) results, pass RandomState instances when creating estimators

> ```python
> rf_inst = RandomForestClassifier(random_state=np.random.RandomState(0))
> cross_val_score(rf_inst, X, y)
> ```
> ...
> Since `rf_inst` was passed a `RandomState` instance, each call to `fit` starts from a different RNG. As a result, the random subset of features will be different for each folds

In regards to cloning, the same reference says:
> ```python
> rng = np.random.RandomState(0)
> a = RandomForestClassifier(random_state=rng)
> b = clone(a)
> ```
> Moreover, `a` and `b` will influence each-other since they share the same internal RNG: calling `a.fit` will consume `b`’s RNG, and calling `b.fit` will consume `a`’s RNG, since they are the same. 

The actual behaviour does not follow this description. 

### Steps/Code to Reproduce

```python
import numpy as np
from sklearn import clone
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_validate
from sklearn.ensemble import RandomForestClassifier

rng = np.random.RandomState(0)
X, y = make_classification(random_state=rng)
rf = RandomForestClassifier(random_state=rng)

d = cross_validate(rf, X, y, return_estimator=True, cv=2)
rngs = [e.random_state for e in d['estimator']]
# estimators corresponding to different CV runs have different but identical RNGs:
print(rngs[0] is rngs[1]) # False
print(all(rngs[0].randint(10, size=10) == rngs[1].randint(10, size=10))) # True

rf_clone = clone(rf)
rngs = [rf.random_state, rf_clone.random_state]
print(rngs[0] is rngs[1]) # False
print(all(rngs[0].randint(10, size=10) == rngs[1].randint(10, size=10))) # True
```

### Expected Results

True False True False

### Actual Results

False True False True

### Versions

```shell
Tested on a two-week-old dev build and also on the following version (Kaggle)

System:
    python: 3.7.12 | packaged by conda-forge | (default, Oct 26 2021, 06:08:53)  [GCC 9.4.0]
executable: /opt/conda/bin/python3.7
   machine: Linux-5.15.90+-x86_64-with-debian-bullseye-sid

Python dependencies:
          pip: 22.3.1
   setuptools: 59.8.0
      sklearn: 1.0.2
        numpy: 1.21.6
        scipy: 1.7.3
       Cython: 0.29.34
       pandas: 1.3.5
   matplotlib: 3.5.3
       joblib: 1.2.0
threadpoolctl: 3.1.0

Built with OpenMP: True
```

COMMENT:
I am extremely confused.

We've had plenty of discussions with @GaelVaroquaux , @amueller , @ogrisel , @agramfort  and @adrinjalali [1] about this behaviour and we **all** had the same shared (wrong???) understanding that this snippet passes - i.e. that the `RandomState` instance is shared across clones and that the docs are correct:

```py
rng = np.random.RandomState(0)

rf = RandomForestClassifier(random_state=rng)
rf2 = clone(rf)

assert check_random_state(rf.random_state) is check_random_state(rf2.random_state)
```

So we either got it all wrong all this time, or something changed in the way we `clone()`, or in the way `np.random.RandomState` reacts to being deep-copied?

The current state (wrong docs, `RandomState` instances *not* shared across clones) is quite alarming because it means that the only way to get maximal entropy for scikit-learn estimators is to leave `random_state=None`, which throws reproducibility out of the window. CC @GaelVaroquaux because I know you care about this.

I'm still in the denial phase right now - it has to be a change in `clone()` or in `RandomState` right?? I still remember conversations with core devs claiming that yeah, shared `RandomState` instances across clones is what we have *and* want. I started writing those docs **precisely** because I found those randomness subtleties so confusing and error-prone, and they were never documented before. And I still managed to get it completely wrong, even after [10+ people](https://github.com/scikit-learn/scikit-learn/pull/18363) reviewed the PR??? 


> > As a result I don't think the docs need improving, instead we need to improve the code.
> 
> For that we'd need to revive the SLEP.

Whether we consider this a bugfix or not, implementing the behaviour claimed by the docs is going to be a massive behaviour change - and a silent one. As for SLEP 11, I never submitted it but I wrote a whole new version in https://github.com/NicolasHug/enhancement_proposals/blob/random_state_v2/slep011/proposal.rst. It (wrongly?) assumes `RandomState` instances are shared across clones but there might be relevant ideas in there as to how we can make all this more explicit and less error-prone.

[1] in https://github.com/scikit-learn/enhancement_proposals/pull/24 in https://github.com/scikit-learn/scikit-learn/pull/18363, and offline

Labels: Bug, Documentation, Needs Decision