Add rolling window to sklearn.model_selection.TimeSeriesSplit

### Describe the workflow you want to enable

I wanted to ask whether any plans exist to implement a rolling/sliding window method in the TimeSeriesSplit class:

![68747470733a2f2f692e6962622e636f2f4b576b665137712f6e6577706c6f742e706e67](https://user-images.githubusercontent.com/28893120/154545460-d1629e8a-22a4-494d-affc-2df3cb95ade7.png)

 Currently, we are limited to using the expanding window type. For many financial time series models where a feature experiences a structural break, having a model whose weights are trained on the entire history can prove suboptimal.

I noted in https://github.com/scikit-learn/scikit-learn/pull/13204, specifically svenstehle's comments, that this might be on the horizon? 

### Describe your proposed solution

Current Implementation

```
>>> x = np.arange(15)
>>> cv = TimeSeriesSplit(n_splits=3, gap=2)
>>> for train_index, test_index in cv.split(x):
...      print("TRAIN:", train_index, "TEST:", test_index)
TRAIN: [0 1 2 3] TEST: [6 7 8]
TRAIN: [0 1 2 3 4 5 6] TEST: [ 9 10 11]
TRAIN: [0 1 2 3 4 5 6 7 8 9] TEST: [12 13 14]
```

Desired outcome

```
>>> x = np.arange(10)
>>> cv = TimeSeriesSplit(n_splits='walk_fw',  max_train_size=3, max_test_size=1)
>>> for train_index, test_index in cv.split(x):
...      print("TRAIN:", train_index, "TEST:", test_index)
TRAIN: [0 1 2] TEST: [3]
TRAIN: [1 2 3] TEST: [ 4]
TRAIN: [2 3 4] TEST: [5]
TRAIN: [ 3 4 5] TEST: [6]
TRAIN: [ 4 5 6] TEST: [7]
TRAIN: [ 5 6 7] TEST: [8]
TRAIN: [ 6 7 8] TEST: [9]
```

Where the 'stride' of the walk forward is proportionate to the test set, or walks by the max_train_size parameter?



### Describe alternatives you've considered, if relevant

_No response_

### Additional context

_No response_

COMMENT:
I have created a class for this in the past for my own usage in personal projects where the calculations for max_train_size and test_size are done automatically given the number of splits desired and the proportion of the window allocated to validation. The calculation works out that the window size is equal to the number of samples times the reciprocal of `1 + (validation proportion * (n_splits - 1))`.

For example: given a validation proportion of `0.2` (20% of each window is allocated to validation) and a number of folds at `4`, the totality of the time steps given must be made up by `1 + (0.2 * 3) = 1.6` windows placed end-to-end. Given a number of time steps `N=1000` we get that each window is `(1 / 1.6) * 1000 = 625` steps, thus the validation and also shifting amount of each window is `625 * 0.2 = 125` steps.

Another example using the values of previous discussions: if we set `max_train_size=3` and `test_size=1` it is the same as setting the validation proportion to `0.25` and the number of folds to `12`. We then get that for a given sample size we will need to place `1 + (0.25 * 11) = 3.75` windows end-to-end, and thus our window size (in the class it is given the variable `batch_size`) is 26.66% of the total sample size. At 15 time steps this leaves us at 4 samples per window, with the first 3 used for training and the last 1 used for validation.

In my use case I also needed support for longitudinal data, thus the class allows for a time column to be used for window definition as well. An example of the class applied to multiple stocks is shown below. The code for the class and PR for scikit-learn inclusion are both given at #24589.

![image](https://user-images.githubusercontent.com/6786406/194393684-33d19568-39d7-4e2a-8c55-f0408d8a7fc8.png)

If inclusion is decided against you may copy the class into a python file, remove the _BaseKFold super, and add an n_splits getter. The only 3 requirements when used as a standalone module are as follows:
```
import numpy as np
from sklearn.utils import indexable
from sklearn.utils.validation import _num_samples
```

Labels: New Feature, module:model_selection