Replace `as_target` context managers by direct calls
# What does this PR do?

This PR deprecates the context managers `as_target_tokenizer` and `as_target_processor` to the profit of passing more arguments to the `__call__` method (or the `pad` method for certain processors).

Let's look at one example for a tokenizer in a seq2seq task. The current workflow is:
```python
# Tokeniz inputs
model_inputs = tokenizer(inputs, max_length=128, truncation=True)
# Tokenize labels inside the context manager
with tokenizer.as_target_tokenizer():
    labels = tokenizer(targets, max_length=128, truncation=True)
# Put everything together
model_inputs["labels"] = labels["input_ids"]
```

After this PR, this simply becomes:
```python
model_inputs = tokenizer(inputs, text_target=targets, max_length=128, truncation=True)
```
which is more natural and way easier.

It gets tricky if:
1. you want to tokenizer the targets with different keyword arguments
2. you want to add more than the input IDs for the targets to your model inputs.
In this case you still need to do two calls:
```python
# Tokenize inputs
model_inputs = tokenizer(inputs, max_length=128, truncation=True)
# Tokenize labels
labels = tokenizer(text_target=targets, max_length=64, truncation=True)
# Put everything together
model_inputs["labels"] = labels["input_ids"]
model_inputs["labels_mask"] = labels["attention_mask"]
```

Like before, if you forget to indicate to the tokenizer you are tokenizing labels (here by passing them as `text_target=...` (and before by tokenizing under the context manager), the labels will be tokenized like the inputs.


For processors, the same changes are done, except you can directly use modality names:
```python
input_values = processor(ds[0]["audio"]["array"], return_tensors="pt")
with processor.as_target_processor():
    labels = processor(ds[0]["text"], return_tensors="pt")
input_values["labels"] = labels["input_ids"]
```
can now simply be:
```python
input_values = processor(audio=ds[0]["audio"]["array"], text=processor(ds[0]["text"], return_tensors="pt")
```
Like before, you can also do it in two individual calls (with `audio` and `text`) to get the objects if you need to use different values of keyword arguments, or want to do a more complex merge than just taking the label input IDs.

Padding is also treated: previous code required to do something like this:
```python
batch = self.processor.pad(input_features, padding=padding, return_tensors="pt")
with self.processor.as_target_processor():
    labels_batch = self.processor.pad(label_features, padding=self.padding, return_tensors="pt")
batch["labels"] = labels_batch["input_ids"]
```
This can now be done with:
```python
batch = self.processor.pad(input_features, labels=label_features, padding=padding, return_tensors="pt")
```
or in two calls like before if something more involved (different keyword arguments for labels or accessing more than the labels input IDs) is needed.

This comes at no breaking change.

Current version does not touch any of the documentation, examples and tests (to double-check there is no breaking change), those will need to be adapted. This can be done in this PR or in followups if you prefer to read lighter diffs.
_The documentation is not available anymore as the PR was closed or merged._