TransformedTargetRegressor is incompatible with GaussianProcessRegressor when using return_std=True

### Describe the bug

`TransformedTargetRegressor` is incompatible with `GaussianProcessRegressor` when using `return_std=True` due to the fact that the model returns a tuple rather than an array.



### Steps/Code to Reproduce

```python
import numpy as np

from sklearn.preprocessing import PowerTransformer
from sklearn.compose import TransformedTargetRegressor
from sklearn.gaussian_process import GaussianProcessRegressor

from sklearn.datasets import fetch_openml
from sklearn.utils import shuffle

from sklearn.model_selection import train_test_split
from sklearn.compose import make_column_transformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OrdinalEncoder
from sklearn.compose import make_column_selector

def load_ames_housing():
    df = fetch_openml(name="house_prices", as_frame=True)
    X = df.data
    y = df.target

    features = [
        "YrSold",
        "HeatingQC",
        "Street",
        "YearRemodAdd",
        "Heating",
        "MasVnrType",
        "BsmtUnfSF",
        "Foundation",
        "MasVnrArea",
        "MSSubClass",
        "ExterQual",
        "Condition2",
        "GarageCars",
        "GarageType",
        "OverallQual",
        "TotalBsmtSF",
        "BsmtFinSF1",
        "HouseStyle",
        "MiscFeature",
        "MoSold",
    ]

    X = X[features]
    X, y = shuffle(X, y, random_state=0)

    X = X[:600]
    y = y[:600]
    return X, np.log(y)

X, y = load_ames_housing()

cat_selector = make_column_selector(dtype_include=object)
num_selector = make_column_selector(dtype_include=np.number)

cat_tree_processor = OrdinalEncoder(
    handle_unknown="use_encoded_value", unknown_value=-1
)
num_tree_processor = SimpleImputer(strategy="mean", add_indicator=True)

tree_preprocessor = make_column_transformer(
    (num_tree_processor, num_selector), (cat_tree_processor, cat_selector)
)

X_train, X_test, y_train, y_test = train_test_split(X, y)

X_train = tree_preprocessor.fit_transform(X_train)
X_test = tree_preprocessor.transform(X_test)

gpr = GaussianProcessRegressor(random_state=0)
yj = PowerTransformer("yeo-johnson")
tt_gpr = TransformedTargetRegressor(gpr, transformer=yj)

tt_gpr.fit(X_train, y_train)

tt_gpr.predict(X_test, return_std=True)
```

### Expected Results

Predictions are returned from the transformed regressor. It is potentially unclear how the transformer should apply to the predictions given that custom behavior is likely required for each type of transformer breaking the `func`, `inverse_func` API. However if this is the case it would be good to have a more informative error message/something in the documentation.

### Actual Results

```
AttributeError                            Traceback (most recent call last)
[<ipython-input-3-43ceeb18ba48>](https://localhost:8080/#) in <module>
     31 tt_gpr.fit(X_train, y_train)
     32 
---> 33 tt_gpr.predict(X_test, return_std=True)

[/usr/local/lib/python3.7/dist-packages/sklearn/compose/_target.py](https://localhost:8080/#) in predict(self, X, **predict_params)
    273         check_is_fitted(self)
    274         pred = self.regressor_.predict(X, **predict_params)
--> 275         if pred.ndim == 1:
    276             pred_trans = self.transformer_.inverse_transform(pred.reshape(-1, 1))
    277         else:

AttributeError: 'tuple' object has no attribute 'ndim'
```

### Versions

```shell
System:
    python: 3.7.14 (default, Sep  8 2022, 00:06:44)  [GCC 7.5.0]
executable: /usr/bin/python3
   machine: Linux-5.10.133+-x86_64-with-Ubuntu-18.04-bionic

Python dependencies:
          pip: 21.1.3
   setuptools: 57.4.0
      sklearn: 1.0.2
        numpy: 1.21.6
        scipy: 1.7.3
       Cython: 0.29.32
       pandas: 1.3.5
   matplotlib: 3.2.2
       joblib: 1.2.0
threadpoolctl: 3.1.0

Built with OpenMP: True
```
```

COMMENT:
Isn't the API such that the only instances in which a tuple is returned are use using `return_std=True` therefore could you not check for that in the `predict_params` and raise an error if true? Afaik the mean is unchanged by most transformations but the moments are.

Labels: Enhancement, module:compose