[SPARK-53334][CONNECT] LiteralValueProtoConverter should keep the order of input map

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

- use `LinkedHashMap` in the `typedLit` test
- make `LiteralValueProtoConverter` keep the order of input map

### Why are the changes needed?
It might increase randomness of transformed literal values, e.g. the `typedLit` test, it is non-determinisitc

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

### How was this patch tested?
ci

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

Closes #52078 from zhengruifeng/proto_test_map.

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

Author: zhengruifeng

sql/connect/client/jvm/src/test/scala/org/apache/spark/sql/PlanGenerationTestSuite.scala

@@ -3405,7 +3405,7 @@ class PlanGenerationTestSuite
       fn.typedLit(Some(1)),
       fn.typedLit(Array(1, 2, 3)),
       fn.typedLit(Seq(1, 2, 3)),
-      fn.typedLit(Map("a" -> 1, "b" -> 2)),
+      fn.typedLit(mutable.LinkedHashMap("a" -> 1, "b" -> 2)),
       fn.typedLit(("a", 2, 1.0)),
       fn.typedLit[Option[Int]](None),
       fn.typedLit[Array[Option[Int]]](Array(Some(1))),
@@ -3414,9 +3414,20 @@ class PlanGenerationTestSuite
       fn.typedlit[collection.immutable.Map[Int, Option[Int]]](
         collection.immutable.Map(1 -> None)),
       fn.typedLit(Seq(Seq(1, 2, 3), Seq(4, 5, 6), Seq(7, 8, 9))),
-      fn.typedLit(Seq(Map("a" -> 1, "b" -> 2), Map("a" -> 3, "b" -> 4), Map("a" -> 5, "b" -> 6))),
-      fn.typedLit(Map(1 -> Map("a" -> 1, "b" -> 2), 2 -> Map("a" -> 3, "b" -> 4))),
-      fn.typedLit((Seq(1, 2, 3), Map("a" -> 1, "b" -> 2), ("a", Map(1 -> "a", 2 -> "b")))))
+      fn.typedLit(
+        Seq(
+          mutable.LinkedHashMap("a" -> 1, "b" -> 2),
+          mutable.LinkedHashMap("a" -> 3, "b" -> 4),
+          mutable.LinkedHashMap("a" -> 5, "b" -> 6))),
+      fn.typedLit(
+        mutable.LinkedHashMap(
+          1 -> mutable.LinkedHashMap("a" -> 1, "b" -> 2),
+          2 -> mutable.LinkedHashMap("a" -> 3, "b" -> 4))),
+      fn.typedLit(
+        (
+          Seq(1, 2, 3),
+          mutable.LinkedHashMap("a" -> 1, "b" -> 2),
+          ("a", mutable.LinkedHashMap(1 -> "a", 2 -> "b")))))
   }
 
   /* Window API */

sql/connect/common/src/main/scala/org/apache/spark/sql/connect/common/LiteralValueProtoConverter.scala

@@ -439,7 +439,7 @@ object LiteralValueProtoConverter {
         valueConverter: proto.Expression.Literal => V)(implicit
         tagK: ClassTag[K],
         tagV: ClassTag[V]): mutable.Map[K, V] = {
-      val builder = mutable.HashMap.empty[K, V]
+      val builder = mutable.LinkedHashMap.empty[K, V]
       val keys = map.getKeysList.asScala
       val values = map.getValuesList.asScala
       builder.sizeHint(keys.size)