Make quote pattern type variable order deterministic (#17938)

This changes the order in which the type variables are listed in the
encoded quote pattern. The order of the variables is the same as the
order as they appear in the source.

Example:
```scala
import scala.quoted.*
def f(x: Expr[Any])(using Quotes) =
  x match
    case '{ type t; type u; Map[v, w]() } =>
```

```scala
[[syntax trees at end of                     typer]] 
package <empty> {
  import scala.quoted.*
  final lazy module val Test$package: Test$package = new Test$package()
  final module class Test$package() extends Object() {
    this: Test$package.type =>
    def f(x: scala.quoted.Expr[Any])(using x$2: scala.quoted.Quotes): Unit =
      x match 
        {
          case 
            x$2.asInstanceOf[scala.quoted.runtime.QuoteMatching].ExprMatch.
              unapply[
              scala.quoted.runtime.QuoteMatching.KCons[t @ _,
                scala.quoted.runtime.QuoteMatching.KCons[u @ _,
                  scala.quoted.runtime.QuoteMatching.KCons[v @ _,
                    scala.quoted.runtime.QuoteMatching.KCons[w @ _,
                      scala.quoted.runtime.QuoteMatching.KNil]
                  ]
                ]
              ],
              (scala.quoted.Type[t], scala.quoted.Type[u],
                scala.quoted.Type[v], scala.quoted.Type[w])
            ](
              Tuple4.unapply[scala.quoted.Type[t], scala.quoted.Type[u],
                scala.quoted.Type[v], scala.quoted.Type[w]](given t$given1 @ _,
                given u$given1 @ _, given v$given1 @ _, given w$given1 @ _)
            )(
              '{
                {
                  @patternType type t >: Nothing <: Any
                  @patternType type u >: Nothing <: Any
                  @patternType type v
                  @patternType type w
                  Map.apply[v, w]([ : (v, w)]*)
                }
              }.apply(x$2)
            )
           =>
            ()
        }
  }
}
```
We want all the places where `t`, `u`, `v` and `w` listed in some way to
be in that same order.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -199,10 +199,10 @@ trait QuotesAndSplices {
    *  )
    *  ```
    */
-  private def splitQuotePattern(quoted: Tree)(using Context): (Map[Symbol, Bind], Tree, List[Tree]) = {
+  private def splitQuotePattern(quoted: Tree)(using Context): (collection.Map[Symbol, Bind], Tree, List[Tree]) = {
     val ctx0 = ctx
 
-    val typeBindings: collection.mutable.Map[Symbol, Bind] = collection.mutable.Map.empty
+    val typeBindings: mutable.Map[Symbol, Bind] = mutable.LinkedHashMap.empty
     def getBinding(sym: Symbol): Bind =
       typeBindings.getOrElseUpdate(sym, {
         val bindingBounds = sym.info
@@ -296,13 +296,19 @@ trait QuotesAndSplices {
       }
     }
     val shape0 = splitter.transform(quoted)
-    val patterns = (splitter.freshTypePatBuf.iterator ++ splitter.typePatBuf.iterator ++ splitter.patBuf.iterator).toList
+    val patterns = (splitter.typePatBuf.iterator ++ splitter.freshTypePatBuf.iterator ++ splitter.patBuf.iterator).toList
     val freshTypeBindings = splitter.freshTypeBindingsBuff.result()
 
-    val shape1 = seq(
-      freshTypeBindings,
-      shape0
-    )
+    val shape1 = shape0 match
+      case Block(stats @ ((tdef: TypeDef) :: rest), expr) if tdef.symbol.hasAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot) =>
+        val (bindings, otherStats) = stats.span {
+          case tdef: TypeDef => tdef.symbol.hasAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot)
+          case _ => true
+        }
+        cpy.Block(shape0)(bindings ::: freshTypeBindings ::: otherStats, expr)
+      case _ =>
+        seq(freshTypeBindings, shape0)
+
     val shape2 =
       if (freshTypeBindings.isEmpty) shape1
       else {
@@ -319,7 +325,7 @@ trait QuotesAndSplices {
         new TreeTypeMap(typeMap = typeMap).transform(shape1)
       }
 
-    (typeBindings.toMap, shape2, patterns)
+    (typeBindings, shape2, patterns)
   }
 
   /** Type a quote pattern `case '{ <quoted> } =>` qiven the a current prototype. Typing the pattern