[SPARK-50749][SQL] Fix ordering bug in CommutativeExpression.gatherCommutative method

### What changes were proposed in this pull request?

[SPARK-49977](https://issues.apache.org/jira/browse/SPARK-49977) introduced a bug in the `CommutativeExpression.gatherCommutative()` method, changing the function's output order.
Consider the following concrete example:

```
val addExpression = Add(
  Literal(1),
  Add(
    Literal(2),
    Literal(3)
  )
)
val commutativeExpressions = addExpression.gatherCommutative(addExpression,
  { case Add(l, r, _) => Seq(l, r)})

```

Consider the output of the `gatherCommutative` method. [SPARK-49977](https://issues.apache.org/jira/browse/SPARK-49977) introduced a bug that reversed the output order. This PR fixes the bug in `gatherCommutative()` to restore the original correct ordered output.

```
// Prior to [SPARK-49977](https://issues.apache.org/jira/browse/SPARK-49977) and after this fix
// commutativeExpressions -> Seq(Literal(1), Literal(2), Literal(3)))
// Post [SPARK-49977](https://issues.apache.org/jira/browse/SPARK-49977) and before this fix
// commutativeExpressions -> Seq(Literal(3), Literal(2), Literal(1)))
```

### Why are the changes needed?

Fixing a bug

### Does this PR introduce _any_ user-facing change?

No

### How was this patch tested?

Added a test

### Was this patch authored or co-authored using generative AI tooling?

Generated-by: ChatGPT

Closes #49392 from utkarsh39/SPARK-50749.

Authored-by: utkarsh39 <[email protected]>
Signed-off-by: Wenchen Fan <[email protected]>

Author: utkarsh39

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/Expression.scala

@@ -1354,19 +1354,24 @@ trait UserDefinedExpression {
 }
 
 trait CommutativeExpression extends Expression {
-  /** Collects adjacent commutative operations. */
-  private def gatherCommutative(
+  /**
+   * Collects adjacent commutative operations.
+   *
+   * Exposed for testing
+   */
+  private[spark] def gatherCommutative(
       e: Expression,
       f: PartialFunction[CommutativeExpression, Seq[Expression]]): Seq[Expression] = {
     val resultBuffer = scala.collection.mutable.Buffer[Expression]()
-    val stack = scala.collection.mutable.Stack[Expression](e)
+    val queue = scala.collection.mutable.Queue[Expression](e)
 
     // [SPARK-49977]: Use iterative approach to avoid creating many temporary List objects
     // for deep expression trees through recursion.
-    while (stack.nonEmpty) {
-      stack.pop() match {
+    while (queue.nonEmpty) {
+      val current = queue.dequeue()
+      current match {
         case c: CommutativeExpression if f.isDefinedAt(c) =>
-          stack.pushAll(f(c))
+          queue ++= f(c)
         case other =>
           resultBuffer += other.canonicalized
       }

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/CanonicalizeSuite.scala

@@ -479,4 +479,17 @@ class CanonicalizeSuite extends SparkFunSuite {
         }
     }
   }
+
+  test("unit test for gatherCommutative()") {
+    val addExpression = Add(
+      Literal(1),
+      Add(
+        Literal(2),
+        Literal(3)
+      )
+    )
+    val commutativeExpressions = addExpression.gatherCommutative(addExpression,
+      { case Add(l, r, _) => Seq(l, r)})
+    assert(commutativeExpressions == Seq(Literal(1), Literal(2), Literal(3)))
+  }
 }