RidgeCV replacement for normalize=True gives different results

### Describe the bug

Running RidgeCV with `normalize=True` results in a Future Warning that provides the new preferred method for normalizing prior to fitting a regularized regression:
FutureWarning: 'normalize' was deprecated in version 1.0 and will be removed in 1.2.
If you wish to scale the data, use Pipeline with a StandardScaler in a preprocessing stage. To reproduce the previous behavior:
```python
from sklearn.pipeline import make_pipeline

model = make_pipeline(StandardScaler(with_mean=False), _RidgeGCV())
```

However, when I try to implement this, I get very different results than with normalize=True, making me think perhaps I didn't know what normalize was doing in the first place.

### Steps/Code to Reproduce

```python
from sklearn.datasets import make_regression
from sklearn import linear_model
from sklearn.pipeline import make_pipeline

X, y, w = make_regression(
    n_samples=10, n_features=10, coef=True, random_state=1, bias=3.5
)

reg = linear_model.RidgeCV(normalize=True)

reg.fit(X, y)
print('old method: ', reg.coef_, reg.intercept_, reg.alpha_, reg.predict(X))

model = make_pipeline(StandardScaler(with_mean=False), linear_model.RidgeCV())
model.fit(X, y)
print('new method: ',model['ridgecv'].coef_, model['ridgecv'].intercept_, model['ridgecv'].alpha_, model.predict(X))
```

### Expected Results

I would expect these to have the same result.

### Actual Results

```
old method:  [ 31.71587415 -22.24842109  16.39309719  21.21120971   6.0422928
  55.09416648  12.35520845 -31.34002266  41.30725923  71.19405147] 20.03577681177929 0.1 [  25.21745712   53.95958306  -68.09400539 -201.61697665   48.18804729
   -2.41519428   30.21811352  -25.23316533  108.24806911   27.85799418]
```
```
new method:  [ 64.42944029 -12.21304369  20.65494721  18.33833625   5.31778008
  50.76979275   9.707485   -16.44095044  51.70245172  23.1077787 ] 30.278259703366963 0.1 [  42.1051797    59.36215179  -82.18834535 -215.193882     55.814325
   -1.73335152   30.27829894  -40.63725969  108.43678068   40.08602508]
```
### Versions

```shell
System:
    python: 3.7.9 (default, Aug 31 2020, 12:42:55)  [GCC 7.3.0]
executable: /home1/djhalp/.conda/envs/cml/bin/python
   machine: Linux-3.10.0-693.17.1.el7.x86_64-x86_64-with-centos-7.4.1708-Core

Python dependencies:
          pip: 21.2.2
   setuptools: 58.0.4
      sklearn: 1.0.2
        numpy: 1.20.3
        scipy: 1.7.1
       Cython: 0.29.23
       pandas: 1.3.5
   matplotlib: 3.5.0
       joblib: 1.1.0
threadpoolctl: 2.2.0

Built with OpenMP: True
```

COMMENT:
More general remark, the default grid of alphas for `RidgeCV` is too coarse and narrow.

```python
>>> from sklearn.linear_model import RidgeCV
>>> RidgeCV().alphas
(0.1, 1.0, 10.0)
```

I think we should use something like `np.logspace(-6, 6, 13)`:

```python
>>> np.logspace(-6, 6, 13)
array([1.e-06, 1.e-05, 1.e-04, 1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01,
       1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06])
```

or even `np.logspace(-6, 6, 25)` since `RidgeCV` scales very well with the cardinality of `alphas`.

By using a fine and wide grid, the dependency on the scaling of the optimal `alpha` should mostly go away.

Labels: Bug, module:linear_model