I spot my error, I was switching the instantiation of the classes: the custom transformers have to be instantiated inside the ColumnTransformer, while the ColumnTransformer does not have to be instantiated inside the pipeline.

The correct code is the following:

transformation_pipeline = ColumnTransformer([
    ('adoption', TransformAdoptionFeatures(), features_adoption),
    ('census', TransformCensusFeaturesRegr(), features_census),
    ('climate', TransformClimateFeatures(), features_climate),
    ('soil', TransformSoilFeatures(), features_soil),
    ('economic', TransformEconomicFeatures(), features_economic)
],
    remainder='drop')

full_pipeline_stand = Pipeline([
    ('transformation', transformation_pipeline),
    ('scaling', StandardScaler())
])

I finally found a solution to this, thanks to @Alexander's suggestion of chaining ColumnTransformers into a Pipeline. (TLDR: Don't forget that you can create a Pipeline of ColumnTransformers, using remainder='passthrough' to your advantage.)

I first created a ColumnTransformer that concatenates the transformations for both numeric and categorical variables, but without the PCA.

ct = ColumnTransformer([
                        ('non_skewed_num', non_skewed_num_pipe, non_skewed_vars),
                        ('skewed_num', skewed_num_pipe, skewed_vars),
                        ('cat_pipe1', cat_pipe1, cat_vars1),
                        ('cat_pipe2', cat_pipe2, cat_vars2)
                        ], remainder='drop')

Then, I created a ColumnTransformer just for the PCA, and when I specified which columns to apply this to, I used a slice object since this ColumnTransformer will be fed a NumPy array--not a DataFrame--in the eventual Pipeline (it will be the second ColumnTransformer in the Pipeline). I also set remainder='passthrough' so the non-numeric variables will be retained untransformed after the PCA.

ct2 = ColumnTransformer([('dim_reduc', PCA(n_components=5), slice(0, 37))], remainder='passthrough')  # 37 is number of numeric variables

Finally, I created a Pipeline chaining these two ColumnTransformers

final_pipe = Pipeline([('ct', ct), 
                       ('ct2', ct2)])

Calling final_pipe.fit_transform(train_df) yields the cleaned array I wanted. Hope this helps!

You might nest a Pipeline which takes care of the preprocessing of the numerical columns (performed serially) within the ColumnTransformer instance.

Here's an example:

import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X = pd.DataFrame({'city': ['London', 'London', '', 'Sallisaw'],
          'title': ['His Last Bow', 'How Watson Learned the Trick', 'A Moveable Feast', 'The Grapes of Wrath'],
          'expert_rating': [5, 3, np.nan, 5],
          'user_rating': [4, np.nan, 4, 3]})

numeric_columns = list(X.select_dtypes('float64').columns)
cat_columns = list(X.select_dtypes('object').columns) + list(X.select_dtypes('int64').columns)

imp_mean = SimpleImputer(strategy='mean')
imp_freq = SimpleImputer(missing_values='', strategy='most_frequent')

ct = ColumnTransformer([
        ('Imput_freq', imp_freq, cat_columns),
        ('pipe_num', Pipeline([('Imput_mean', imp_mean), ('num', StandardScaler())]), numeric_columns)
    ], remainder='passthrough'
)

pd.DataFrame(ct.fit_transform(X))

Here's a similar post: How to execute both parallel and serial transformations with sklearn pipeline?.