TimeSeriesSplit Needs a version that allows users to specify initial time

### Describe the workflow you want to enable

I would like to add a new `TimeSeriesSplit` [link](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html) called `TimeSeriesRollingOriginSplit`. In the current `TimeSeriesSplit` it is not possible for users to get an initial length.

I am happy to open a PR for this myself if it is approved.


### Describe your proposed solution


This is the proposed new `TimeSeriesRollingOriginSplit`
`class sklearn.model_selection.TimeSeriesRollingOriginSplit(initial = 5, test_size = 1, gap = 0)`

`initial`: the initial number of samples to use. it is often common to start with a larger training period.

`test_size`: Used to set the test_size

`gap`: Number of samples to exclude from the end of each train set before the test set.


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

I currently use `TimeSeriesSplit` in a loop, but exclude the initial splits until the train set is the size I want.

### Additional context

Again. I am happy to contribute this feature.

COMMENT:
Currently, if you set up `TimeSeriesSplit` over data with `n_samples` and set parameters `n_splits, test_size` then you observe the relationship: `initial = n_samples - n_splits * test_size - gap`.  Although you can't guarantee the exact initial size, you can guarantee a lower bound. Is it not sufficient to calculate a good choice of `n_splits`, `test_size`, or `gap` depending on which you want to keep fixed, and then just use the existing `TimeSeriesSplit`?

Repurposing your examples, we get:

<details> 
<summary> Code sample 1</summary>

```python
import numpy as np
from sklearn.model_selection import TimeSeriesSplit

X = np.arange(0,50)
y = np.random.randint(0, 2, 50)

test_size = 7
gap = 0
n_samples = len(X)
n_splits = 4
print(f"Initial = {n_samples - n_splits * test_size - gap}") # Initial = 22

tscv = TimeSeriesSplit(n_splits=n_splits, test_size=test_size, gap=gap)
for train_index, test_index in tscv.split(X):
   print("TRAIN:", train_index, "TEST:", test_index)
# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21] 
# TEST: [22 23 24 25 26 27 28]

# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28] 
# TEST: [29 30 31 32 33 34 35]

# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35] 
# TEST: [36 37 38 39 40 41 42]

# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42]
# TEST: [43 44 45 46 47 48 49]
```

</details>

<details> 
<summary> Code sample 2</summary>

```python
import numpy as np
from sklearn.model_selection import TimeSeriesSplit

X = np.arange(0,50)
y = np.random.randint(0, 2, 50)

test_size = 7
gap = 2
n_samples = len(X)
n_splits = 4
print(f"Initial = {n_samples - n_splits * test_size - gap}") # Initial = 22

tscv = TimeSeriesSplit(n_splits=n_splits, test_size=test_size, gap=gap)
for train_index, test_index in tscv.split(X):
   print("TRAIN:", train_index, "TEST:", test_index)
# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21] 
# TEST: [22 23 24 25 26 27 28]

# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28] 
# TEST: [29 30 31 32 33 34 35]

# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35] 
# TEST: [36 37 38 39 40 41 42]

# TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42]
# TEST: [43 44 45 46 47 48 49]
```

</details>

If there's a strong reason to require setting the _exact_ initial size, then something like a `max_initial_size` parameter (since a user's choice of `n_splits, gap, test_size` fully determines the lower bound of initial_size) would be sufficient, and pretty easily implemented (probably like ~3 lines of substance, plus validation and error-handling code).

Edit: one could change https://github.com/scikit-learn/scikit-learn/blob/ceeda362402bfc978bcc93d02481fe28e21a07ad/sklearn/model_selection/_split.py#L1088

to

```python
initial_value = n_samples - n_splits * test_size - gap

# self.max_initial_size must be > 0 if not None
offset = 0 if self.max_initial_size is None else initial_value - self.max_initial_size
test_starts = range(
    n_samples - n_splits * test_size - offset,
    n_samples - offset % test_size,
    test_size,
)
```

Labels: New Feature, module:model_selection, Needs Decision - Include Feature