Add handle_missing and handle_unknown options to TargetEncoder

### Describe the workflow you want to enable

This issue has a similar proposition then #17123, in which is discussed the addition of `handle_missing` and `handle_unknown` from `OrdinalEncoder`  in  `category_encoders` library. The justification for it is that we should allow users to treat the NaN values as they wish, whether by imputation, algorithms robust to missing data or by any another approach. 

To see if this change can have a positive impact on modeling, I decided to run a Cross Validation in order to compare the performance of `category_encoders.target_encoder.TargetEncoder` allowing to return NaN values ​​and allowing to return a value (target mean).

```python

from ucimlrepo import fetch_ucirepo 
from sklearn.ensemble import BaggingClassifier
from sklearn.pipeline import Pipeline
from category_encoders import TargetEncoder
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score, StratifiedKFold
import matplotlib.pyplot as plt
#%%

adult = fetch_ucirepo(id=2) 
  
X = adult.data.features 
y = adult.data.targets 

y = y['income'].str.contains('>50K')

# %%

kf = StratifiedKFold(5, shuffle = True, random_state = 101)

return_nan_clf = Pipeline([
    ('encoder', TargetEncoder(handle_unknown='return_nan',
                                  handle_missing='return_nan')),
    ('classifier', BaggingClassifier(
        DecisionTreeClassifier(
            max_features = 'sqrt'
            ),
        n_estimators=100,
        
        ))
    ])

mean_clf = Pipeline([
    ('encoder', TargetEncoder(handle_unknown='value',
                                  handle_missing='value')),
    ('classifier', BaggingClassifier(
        DecisionTreeClassifier(
            max_features = 'sqrt'
            ),
        n_estimators=100,
        ))
    ])

# %%

return_nan_cv = cross_val_score(return_nan_clf, X, y, cv = kf, verbose = 3,
                                scoring = 'f1')

print(f'\nAllowing Missing Data CV F1 score: {return_nan_cv.mean():.3f}\n')

mean_cv = cross_val_score(mean_clf, X, y, cv = kf, verbose = 3,
                          scoring = 'f1')

print(f'\nTreating Missing Data CV F1 score: {mean_cv.mean():.3f}')

# %%

fig, ax = plt.subplots(1, 1, figsize = (12, 6))

diff_cv = return_nan_cv - mean_cv

colors = ['b', 'b', 'r', 'b', 'b']

ax.set_title('Difference between allowing NaN values and treating them during encoding',
             fontsize = 15)
ax.bar(range(1, diff_cv.size + 1), diff_cv, color = colors)
ax.set_ylim(-0.002, 0.010)
ax.set_ylabel('F1 Score', fontsize = 15)
ax.set_xlabel('Folds', fontsize = 15)
ax.tick_params(axis='both', which='major', labelsize=12)
``` 
![image](https://github.com/scikit-learn/scikit-learn/assets/34726102/6ec103a9-01bf-466d-a47c-2b7fd76d8253)

As we can clearly see, allowing NaN values resulted in an increase in performance in most Folds. 


### Describe your proposed solution

Adapt the  `handle_missing` and `handle_unknown` options from `category_encoders.target_encoder.TargetEncoder` to `sklearn.preprocessing.TargetEncoder`.

### Describe alternatives you've considered, if relevant

_No response_

### Additional context

_No response_

COMMENT:
I assume that it makes sense to have some options there since we could forward missing values to model that handles them natively.

We need to define how those parameter should behave for the specific case of the `TargetEncoder`.

Labels: New Feature