Feat: DummyClassifier strategy that produces randomized probabilities

### Describe the workflow you want to enable

# Motivation

The `dummy` module is fantastic for testing pipelines all the way up through enterprise scales. The [strategies](https://github.com/scikit-learn/scikit-learn/blob/98ed9dc73/sklearn/dummy.py#L374) offered in the `DummyClassifier` are excellent for testing corner cases. However, the strategies offered fall short when testing pipelines that include downstream tasks that depend on moments of the predicted probabilities (e.g. gains charts).

This is because the existing strategies do not include sampling _random probabilities_.

## Proposed API:

Consider adding a new strategy with a name like `uniform-proba` or `score-random` or something similar that results in this behavior for binary classification:

```python
print(DummyClassifier(strategy="uniform-proba").fit(X, y).predict_proba(X))
"""
[[0.5651713  0.4348287 ]
 [0.36557341 0.63442659]
 [0.42386353 0.57613647]
 ...
 [0.30348692 0.69651308]
 [0.59589879 0.40410121]
 [0.32664176 0.67335824]]
"""
```

### Describe your proposed solution

## Proposed implementation

I had something like this in mind:
```python
class DummyClassifier(MultiOutputMixin, ClassifierMixin, BaseEstimator):
    ...

    def predict_proba(self, X):
        ...
        for k in range(self.n_outputs_):
            if self._strategy == "uniform-proba":
                out = rs.dirichlet([1] * n_classes_[k], size=n_samples)
                out = out.astype(np.float64)
            ...
```

Similar to the `"stratified"` strategy, this simple implementation relies on `numpy.random`, in this case the [`dirichlet`](https://numpy.org/doc/2.0/reference/random/generated/numpy.random.RandomState.dirichlet.html) distribution. By setting all the `alpha`s to 1, we are specifying that the probabilities of each class are equally distributed -- in contrast, the `"stratified"` strategy effectively samples from a dirichlet distribution with one alpha equal to 1 and the rest equal to 0.


### Describe alternatives you've considered, if relevant

_No response_

### Additional context

I am happy to make the PR. The biggest question is what the strategy string should be.

Thank you for reading 🙏.

COMMENT:
👋 hey @glevv @betatim @ogrisel. I'm circling back to poke at this feature request and the PR that implements it #31488 

I still think this is a worthwhile addition, and I gave my 2cents on the name `uniform-proba` in [this comment](https://github.com/scikit-learn/scikit-learn/pull/31488#issuecomment-2954129192).

@glevv to elaborate on my earlier message -- I encourage you to appreciate that other folks might find more usefulness from use cases _other_ than model selection :). Specifically, I think you are under-estimating the usefulness of these `Dummy` models in test suites.

Let me elaborate more and not just say "but gains charts!". Here is a very realistic ML system:

1. we train a model
2. save artifacts
3. load artifacts in a predict setting
4. predict on data
5. intervene on the predictions

Real engineers at real companies build tests for these systems front-to-back. I'm not talking hypotheticals! Typically, we require that tests be fast, hence `Dummy` models are used from step (1) forward. The key here, is that step (5) might include interventions that depend on the output of `predict_proba()`!

Consider, for example, a world where I'm building a churn model for some company. Maybe step (5) is something like:

* raise an alert to account managers for the top 10% riskiest customers and
* offer a discount to the next 10% riskiest customers and
* send en email to the next 20% riskiest and
* do nothing for the bottom 60% of customers"

To fully test this system, we need entropy in the output of `predict_proba()`. The `uniform` strategy won't suffice, because all of the `predict_proba()` outputs are either 0 or 1, meaning there is (almost certainly) no percentiles with samples except the 100th and 50th percentile. That is, with `strategy="uniform"`, ~50% of customers are tied at "max riskiness", and the rest are tied at mid-riskiness. Our test will not be able to cover the "offer a discount..." and "send an email..." branches of logic!

I hope that this real world example of an application of the strategy I proposed is motivating enough to include it in sklearn. Like I said earlier, I have personally witnessed its implementation in a `Dummy`-like class on numerous occasions. And, I hope you three will agree that use cases _beyond_ model selection will benefit from this functionality.

Cheers! 🚀

Labels: New Feature, Needs Decision - Include Feature