Do not harmonize constant args if their type doesn't affect resType

Fixes the following sample from scala#9939:
```scala
scala> f"${3.14}%.2f rounds to ${3}%d"
1 |f"${3.14}%.2f rounds to ${3}%d"
  |                          ^
  |                          type mismatch;
  |                           found   : Double
  |                           required: Int
  | This location contains code that was inlined from rs$line$2:1
```

At the moment when StringInterpolation transformation was performed instead
of receiving `List(Constant(3.0), Constant(3))` arguments they
were: `List(Constant(3.0), Constant(3.0))` (the second one was converted to double because of harmonization).
That caused the reported type mismatch.

In Scala2 harmonization doesn't happen if the resulting type is fully defined.
For f-interp it shouldn't happen too as it's resulting type is a `String`:
```scala
  def f[A >: Any](args: A*): String = macro ???
```

Author: dos65

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

@@ -744,7 +744,10 @@ trait Applications extends Compatibility {
       typedArgBuf += seqToRepeated(SeqLiteral(args, elemtpt))
     }
 
-    def harmonizeArgs(args: List[TypedArg]): List[Tree] = harmonize(args)
+    def harmonizeArgs(args: List[TypedArg]): List[Tree] =
+      // harmonize args only if resType depends on parameter types
+      if (isFullyDefined(methodType.resType, ForceDegree.none)) args
+      else harmonize(args)
 
     override def appPos: SrcPos = app.srcPos
 

tests/run-macros/f-interpolator-tests.check

@@ -1,6 +1,7 @@
 integer: 5
 string: l
 5, 6, hello
+3.14 rounds to 3
 5
 6
 Bob is  1 years old

tests/run-macros/f-interpolator-tests.scala

@@ -10,6 +10,7 @@ object Test {
     println(f"integer: ${5}%d")
     println(f"string: ${"l"}%s")
     println(f"${5}%s, ${6}%d, ${"hello"}%s")
+    println(f"${3.14}%.2f rounds to ${3}%d")
 
     val x = 5
     println(f"$x%d")

tests/run/i9939.check

@@ -0,0 +1,2 @@
+[3.0, 42]
+[3.0, 42.0]

tests/run/i9939.scala

@@ -0,0 +1,6 @@
+def nonHarmonized[A >: Any](args: A*): String = args.mkString("[", ", ", "]")
+def harmonized[A >: Any](args: A*): List[A] = args.toList
+
+@main def Test =
+  println(nonHarmonized(3.0, 42))
+  println(harmonized(3.0, 42).mkString("[", ", ", "]"))