CI : Numerical flakiness in test_enet_ols_consistency

### Describe the bug

While working on another scikit-learn PR (**#32368**), CI intermittently failed in `sklearn/linear_model/tests/test_coordinate_descent.py::test_enet_ols_consistency`.It came from a strict numerical ordering assertion on the squared error:

```python
assert se_enet <= se_ols <= 1e-20
```

This was recently merged 2 days ago in #32845 . On further digging, I noticed:

* the squared error is computed **without `sample_weight`**, even though both models are fit with `sample_weight`
* Lot of tests in this test file are using a **hard-coded RNG seed** (`RandomState(42)`) instead of `global_random_seed` ( I did have a look at #22827 ) 
* when running across multiple seeds (e.g. with `SKLEARN_TESTS_GLOBAL_RANDOM_SEED=all`), additional failures can appear for some configurations due to **tight absolute tolerances** on `intercept_` comparisons near zero.

P.S Same test was passing for seed 42 on Windows locally. However as i start changing seeds it would fail on Windows too. 


### Steps/Code to Reproduce

I updated this test to use `global_random_seed` and ran it for all seeds on Ubuntu. 

```bash
SKLEARN_TESTS_GLOBAL_RANDOM_SEED=all pytest sklearn/linear_model/tests/test_coordinate_descent.py -k test_enet_ols_consistency
```


```python
@pytest.mark.filterwarnings("ignore:With alpha=0, this algorithm:UserWarning")
@pytest.mark.parametrize("precompute", [False, True])
@pytest.mark.parametrize("effective_rank", [None, 10])
def test_enet_ols_consistency(precompute, effective_rank,global_random_seed):
    """Test that ElasticNet(alpha=0) converges to the same solution as OLS."""
    rng = np.random.RandomState(global_random_seed)
    n_samples = 300
    X, y = make_regression(
        n_samples=n_samples,
        n_features=100,
        effective_rank=effective_rank,
        n_informative=50,
        random_state=rng,
    )
    sw = rng.uniform(low=0.01, high=10, size=X.shape[0])

    ols = LinearRegression().fit(X, y, sample_weight=sw)
    enet = ElasticNet(alpha=0, precompute=precompute, tol=1e-15).fit(
        X, y, sample_weight=sw
    )

    # Might be a singular problem, so check for same predictions
    assert_allclose(enet.predict(X), ols.predict(X))
    # and for similar objective function (squared error)
    se_ols = np.sum((y - ols.predict(X)) ** 2)
    se_enet = np.sum((y - enet.predict(X)) ** 2)
    if precompute:
        assert se_ols <= 1e-20
        assert se_enet <= 1e-20
    else:
        assert se_enet <= se_ols <= 1e-20  # Who would have thought that?
    # We check equal coefficients, but "only" with absolute tolerance.
    assert_allclose(enet.coef_, ols.coef_, atol=1e-11)
    assert_allclose(enet.intercept_, ols.intercept_, atol=1e-12)
```


### Expected Results

No test failures

### Actual Results

Reference CI failure (exact run):

```text
https://dev.azure.com/scikit-learn/scikit-learn/_build/results?buildId=83843&view=ms.vss-test-web.build-test-results-tab&runId=837146&resultId=115395&paneView=debug
```

For  my local run, 

```bash
FAILED sklearn/linear_model/tests/test_coordinate_descent.py::test_enet_ols_consistency[42-10-False] - assert 7.304604230718523e-26 <= 6.721669301829635e-26
FAILED sklearn/linear_model/tests/test_coordinate_descent.py::test_enet_ols_consistency[59-None-True] - AssertionError:
```

### Versions

```shell
System:
    python: 3.11.14 | packaged by conda-forge | (main, Oct 22 2025, 22:46:25) [GCC 14.3.0]
executable: /home/gauta/miniforge3/envs/scikit-learn-min-dependencies/bin/python3
   machine: Linux-6.6.87.2-microsoft-standard-WSL2-x86_64-with-glibc2.39

Python dependencies:
      sklearn: 1.9.dev0
          pip: 25.3
   setuptools: 80.9.0
        numpy: 1.24.1
        scipy: 1.10.0
       Cython: 3.1.2
       pandas: 1.5.0
   matplotlib: 3.6.1
       joblib: 1.3.0
threadpoolctl: 3.2.0

Built with OpenMP: True

threadpoolctl info:
       user_api: blas
   internal_api: openblas
    num_threads: 32
         prefix: libopenblas
       filepath: /home/gauta/miniforge3/envs/scikit-learn-min-dependencies/lib/libopenblasp-r0.3.25.so
        version: 0.3.25
threading_layer: pthreads
   architecture: Haswell

       user_api: openmp
   internal_api: openmp
    num_threads: 32
         prefix: libomp
       filepath: /home/gauta/miniforge3/envs/scikit-learn-min-dependencies/lib/libomp.so
        version: None
```

COMMENT:
CC: @lorentzenchr 
Do you think we should remove the special check in this test `se_enet <= se_ols` and also maybe take sample_weight into account when computing both these values, though I am not sure whether sample_weight is required since we are just comparing the objective values so it seems okay to neglect the additional weight constants for both.

Labels: Bug, module:linear_model, module:test-suite