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:
We looked at the problem during the triage meeting.
For this particular case, we would not know how to transform the `std` and we should indeed raise a better error message regarding the output of the regressor. For instance, the line getting the prediction is:

```python
pred = self.regressor_.predict(X, **predict_params)
```

We should check the type for `pred` and give a better error message. If a tuple, we could inform that we would expect the regressor to return a single `ndarray`. It could be a bit tricky to find the exact types that are allowed. We would also like to avoid checking all `predict_params` since we should be lenient towards third-party regressors.

Labels: Enhancement, module:compose