sklearn.compose.ColumnTransformer do not keep transformers` desired dtype of output

Hi,

We are using ColumnTransformer as our unified preprocessor to transform the data. We have the following transformers:

```python
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, FunctionTransformer



mean_imputer_pipline = Pipeline(steps=[('imputer', SimpleImputer(strategy='mean'))])
constan_one_imputer_pipline = Pipeline(steps=[('imputer', SimpleImputer(strategy='constant', fill_value=1.0))])
constan_zero_imputer_pipline = Pipeline(steps=[('imputer', SimpleImputer(strategy='constant', fill_value=0.0))])

categorical_transformer = Pipeline(steps=[
        ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
        ('onehot', OneHotEncoder(handle_unknown='ignore', dtype=np.int8))])

ordinal_categories = [determine_mapping(ordinal_feature) for ordinal_feature in ordinal_features]

ordinal_transformer = Pipeline(steps=[('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                                          ('ordinal', OrdinalEncoder(categories=ordinal_categories, dtype=np.int8))])
```

From them we create our ColumnTransformer object:
```python
from sklearn.compose import ColumnTransformer



preprocessor = ColumnTransformer(
        transformers=[
            ('num_mean', mean_imputer_pipline, mean_imputer_features),
            ('num_constant_one', constan_one_imputer_pipline, constant_one_imputer_features),
            ('num_constant_zero', constan_zero_imputer_pipline, constant_zero_imputer_features),
            ('cat', categorical_transformer, categorical_features),
            ('ordinal', ordinal_transformer, ordinal_features)],
        remainder="drop")
```

When we use the ```transform``` method the desired dtypes of output for  ```categorical_transformer``` and ```ordinal_transformer``` that should be ```np.int8``` isn't kept. What we are receiving is numpy's ndarray that its dtype is ```np.float64```.

We debuged the code, and found out that in order to join the outputs from the different transformers the ColumnTransformer is using the method ```np.hstack``` which creates a unified 1 ndarray with one dtype.

Is there a solution?
If not:
1. Please add a warning in the documentation of the ColumnTransformer that the concatenate results won't use the desired dtype of output of the transformers. 
2. Allow us an option to receive the result without concatenation, as a list of ndarrays.

COMMENT:
With version 1.2, as long as estimators outputs dataframes, the dtypes are preserved. Here is a small snippet inspired from the opening comment:

```python
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OrdinalEncoder
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import StandardScaler
import numpy as np
import pandas as pd

ct = ColumnTransformer([
    ("pet_ordinal", OrdinalEncoder(dtype=np.uint16), ["pet"]),
    ("color_ohe", OneHotEncoder(sparse_output=False, dtype=np.uint8), ["color"]),
    ("numerical", StandardScaler(), ["age"]),
], verbose_feature_names_out=False)
ct.set_output(transform="pandas")

X = pd.DataFrame({"pet": ["dog", "snake", "cat"], "age": [1, 2, 4], "color": ["red", "blue", "orange"]})

X_trans = ct.fit_transform(X)

X_trans.dtypes
# pet              uint16
# color_blue        uint8
# color_orange      uint8
# color_red         uint8
# age             float64
# dtype: object
```

The OneHotEncoder and OrdinalEncoder outputs different dtypes and the output of `ColumnTransformer.transform` uses those dtypes. With that in mind, I am closing this issue.

@BenEfrati If your use case does not preserve the data types, then it is a bug. Please open a new issue with a [minimal reproducer](https://scikit-learn.org/stable/developers/minimal_reproducer.html) so we can figure out what the bug is.

Labels: Documentation, module:compose