Fix TF BART for saved model creation
# What does this PR do?

This PR fixes the graph execution issue in order to make BART able to create a proper saved model.

Quick question on the context before going deeper into the PR: At the moment all "fast" and "slow" `TFBart` tests are passing. I thought model creation is already tested currently. What is the exact use case for which `TFBart` currently fails? Should we maybe add a new `modeling_tf_commen.py` test that would prevent other TF models from having the same error?<|||||>Currently the `test_saved_model_with_hidden_states_output` and `test_saved_model_with_attentions_output` are just partially testing the creation of a saved model. When we extend the experiments (such as using use_cache and force the output to be a dict) it fails because some part of the graph was not taken into account when running the slow tests.

I'm currently working on having proper saved model and testing most of the possible cases to create them, and currently TF BART fails for some of them when using a "real" serving approach. You can test it by yourself by adding
```
@tf.function(input_signature=[{
    "input_ids": tf.TensorSpec((None, None), tf.int32, name="input_ids"),
    "attention_mask": tf.TensorSpec((None, None), tf.int32, name="attention_mask"),
    "decoder_input_ids": tf.TensorSpec((None, None), tf.int32, name="decoder_input_ids"),
    "decoder_attention_mask": tf.TensorSpec((None, None), tf.int32, name="decoder_attention_mask"),
}])
def serving(self, inputs):
    output = self.call(inputs)
        
    return self.serving_output(output)

def serving_output(self, output):
        return TFSeq2SeqLMOutput(
            loss=None,
            logits=output.logits,
            past_key_values=output.past_key_values,
            decoder_hidden_states=tf.convert_to_tensor(output.decoder_hidden_states)
            if self.config.output_hidden_states
            else None,
            decoder_attentions=tf.convert_to_tensor(output.decoder_attentions)
            if self.config.output_attentions
            else None,
            encoder_last_hidden_state=output.encoder_last_hidden_state,
            encoder_hidden_states=tf.convert_to_tensor(output.encoder_hidden_states)
            if self.config.output_hidden_states
            else None,
            encoder_attentions=tf.convert_to_tensor(output.decoder_attentions)
            if self.config.output_attentions
            else None,
        )
```

To the `TFBartForConditionalGeneration` and run:
```
from transformers import TFBartForConditionalGeneration
model = TFBartForConditionalGeneration.from_pretrained("sshleifer/bart-tiny-random")
model.save("here", include_optimizer=False, signatures=model.serving)
```

You can see the following error:
```
ValueError: 'combined_attention_mask' is None at the end of the else branch.
```

This is because, as you can see, the given input is different than the one we test with `dummy_inputs` or in the tests. Here we are compiling a part of the graph that is not used in those cases, and when this part comes to be compiled, it fails.

Lessons learned: To properly test the creation of a savedmodel/graph compilation+execution we have to test as much inputs as possible in order to be sure that all the part of the graph can be compiled and executed.

EDIT: I'm also 100% sure that BART is not the only model concerned about this.<|||||>Slow tests are passing as well - just verified on brutasse. PR looks good to me now