Support for Quantized ELU is missing in TFLite MLIR converter
Hi @Doomski99,

I tried `elu` activation on a sample model and converted to tflite with different quantization schemes and it is working fine. Please refer to the [gist](https://colab.sandbox.google.com/gist/LakshmiKalaKadali/cfa3bf0627b74596a8400682ad2b4396/tflite_63065_elu_feature-request.ipynb). If your use case is different from this, please elaborate it w.r.t ` def TFL_EluOp: TFL_Op<"elu" ` in [tfl_ops.td](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/mlir/lite/ir/tfl_ops.td) and  share a reproducible code for further steps.

Thank You  Hello @LakshmiKalaKadali, 

Thanks for taking the time to look at this issue. I was looking at the graphs produced by your gist and they were all the same because I think you were mistakenly saving the original non-quantized model each time:
You've written: 
```
with open("converted_model4.tflite", "wb") as f:
  f.write(tflite_model)
```
Instead of:
```
with open("converted_model4.tflite", "wb") as f:
  f.write(tflite_model_quant)
```
After that modification, you can look at the graph (in this case, converted_model4) and see:
![image](https://github.com/tensorflow/tensorflow/assets/45564681/ff36397c-3e94-4cff-8d89-e109849453ed)
Which is odd, we would expect the converter to output an error since you've added to the code this line:
```
# Ensure that if any ops can't be quantized, the converter throws an error
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
```
and clearly the ELU isn't an INT8 operation in this case. 

Concerning tfl_ops.td, we can confirm that ELU doesn't support quantized inputs from it's definition and by comparing it to LeakyReLU for example:

ELU definition:
```
def TFL_EluOp: TFL_Op<"elu", [
    Pure,
    SameOperandsAndResultShape,
    TFL_SameFirstOperandAndFirstResultElementType]> {
  let summary = "Exponential Linear Unit operator";
  let description = [{
    Computes the exponential linear
      f(x) -> exp(x) - 1 for x < 0, x for x >= 0.
    element-wise.
  }];

  let arguments = (ins TFL_TensorOf<[F32, I8]>:$x);

  let results = (outs TFL_TensorOf<[F32, I8]>:$y);

  let hasOptions = 0;
}
```
LeakyReLU definition:
```
def TFL_LeakyReluOp: TFL_Op<"leaky_relu", [
    SameOperandsAndResultShape,
    QuantizableResult,
    Pure,
    PredOpTrait<"input and output must have same element type",
      TFL_TCresVTEtIsSameAsOp<0, 0>>]> {
  let summary = "Leaky Relu operator";

  let description = [{
    Element-wise Leaky ReLU operator
      x -> x >= 0 ? x : (alpha * x)
  }];

  let arguments = (
    ins TFL_TensorOf<[F32, QUI8, QI8, TFL_Quint8, QI16]>:$input,
    // Slope of the activation function at x < 0.
    F32Attr:$alpha
  );

  let results = (outs TFL_TensorOf<[F32, QUI8, QI8, TFL_Quint8, QI16]>:$output);

  let hasOptions = 0b1;
}
```
Note how ELU is missing the "QuantizableResult" trait and its arguments are missing the quantized data types "QUI8" and "QI8".  Hi @Doomski99 ,

Appreciable your efforts in bringing the feature request to our attention. Yes, as you mentioned `elu`  definition doesn't support  quantizable trait. The observation is clearly presented in the below screenshot.

![image](https://github.com/tensorflow/tensorflow/assets/149650845/272e0b24-5843-4d5f-9bec-70a06256a166)  Our team will work on it and will update you.

Thank You

 Hi @Doomski99,

Please track the PR [#63126](https://github.com/tensorflow/tensorflow/pull/63126), for feature request.

Thank You
**System information**
- OS Platform and Distribution (e.g., Linux Ubuntu 16.04): WSL2 Ubuntu
- TensorFlow installed from (source or binary): pip
- TensorFlow version (or github SHA if from source): Latest

Unlike ReLU for example, currently ELU isn't supported for 8 bit quantization in TFLite:
![image](https://github.com/tensorflow/tensorflow/assets/45564681/55ac6736-2e5a-421e-aedf-f41e541e870d)
I think we can confirm this by looking at ELU's definition in [tfl_ops.td](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/mlir/lite/ir/tfl_ops.td) , it doesn't have the quantizable trait.

While researching upon this issue, I stumbled upon an [old stackoverflow issue ](https://stackoverflow.com/questions/67774808/is-elu-int8-quantisation-working-on-tensorflow-lite) implying that quantized ELU was once supported. Maybe it was skipped after the move to MLIR?

Are there plans to support it? If not, will it be straightforward to implement it by my own?
