`Unpack` and `concat` wrongly transformed into `reshape` in tflite converter
I am able to replicate on tf-nightly consistently, here is the [gist](https://colab.sandbox.google.com/gist/pkgoogle/87b4aa9dda67f8bdead474d0bf56476d/60925.ipynb)

unsure if the reshape is incorrect, but output should be the same after conversion.

Hi, @arfaian can you please take a look?
### 1. System information

- OS Platform and Distribution (e.g., Linux Ubuntu 16.04): Linux Ubuntu 20.04
- TensorFlow installation (pip package or built from source): pip
- TensorFlow library (version, if pip package or github SHA, if built from source): 2.14.0-dev20230602

### 2. Code
This is the minimized code to reproduce the issue:
```python
import tensorflow as tf
import numpy as np
x1 = tf.constant([1., 2., 3., 4.], shape=[2, 2, 1])

class Model(tf.keras.Model):

  def __init__(self):
    super(Model, self).__init__()

  @tf.function(input_signature=[tf.TensorSpec(x1.shape, x1.dtype)])
  def call(self, x):
    unpack_op = tf.raw_ops.Unpack(value=x,num=2,axis=0)
    return tf.concat(unpack_op, -1)
m = Model()
m(x1)
print('Keras mode output: ', m(x1).numpy())

converter = tf.lite.TFLiteConverter.from_keras_model(m)
tflite_model = converter.convert()

def _evaluateTFLiteModel(tflite_model, input_data):
    interpreter = tf.lite.Interpreter(model_content=tflite_model)
    interpreter.allocate_tensors()
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()

    for i in range(len(input_data)):
        interpreter.set_tensor(input_details[i]['index'], input_data[i])
    interpreter.invoke()
    output_data = [interpreter.get_tensor(output_details[i]['index'])
                   for i in range(len(output_details))]
    return output_data
print('Lite mode output: ', _evaluateTFLiteModel(tflite_model,[x1])[0])
tf.lite.experimental.Analyzer.analyze(model_content=tflite_model) #Output IR
```
### 3. Failure after conversion
Output:
```
Keras mode output:  [[1. 3.]
 [2. 4.]]
Lite mode output:  [[1. 2.]
 [3. 4.]]
```
Lite IR:
```
Subgraph#0 main(T#0) -> [T#2]
  Op#0 RESHAPE(T#0, T#1[2, 2]) -> [T#2]

Tensors of Subgraph#0
  T#0(serving_default_args_0:0) shape:[2, 2, 1], type:FLOAT32
  T#1(concat) shape:[2], type:INT32 RO 8 bytes, buffer: 2, data:[2, 2]
  T#2(PartitionedCall:0) shape:[2, 2], type:FLOAT32
```
Model produces wrong results:
- Using ```tf.lite.experimental.Analyzer.analyze```, we can see the entire calculation is wrongly transformed into a single ```RESHAPE``` operator.
