Instantiate Type Vars in completion labels of extension methods

[rochala]

This PR fixes the completion labels for extension methods and old style completion methods.

It required an API change of Completion.scala as it didn't contain enough information to properly create labels on presentation compiler side. Along with this following parts were rewritten to avoid recomputation:

• computation of adjustedPath which is necessary for extension construct completions,
• computation of prefix is now unified across the metals and presentation compilers,
• completionKind was changed, and kind Scope, Member are now part of completion mode.

The biggest change is basically added support for old style extension methods.
I found out that the type var was not instantiated after ImplicitSearch computation, and was only calculated at later stages. I don't have enough knowledge about Inference and Typer to know whether this is a bug or rather an intended behaviour but I managed to solve it without touching the typer:

      def tryToInstantiateTypeVars(conversionTarget: SearchSuccess): Type =
        try
          val typingCtx = ctx.fresh
          inContext(typingCtx):
            val methodRefTree = ref(conversionTarget.ref, needLoad = false)
            val convertedTree = ctx.typer.typedAheadExpr(untpd.Apply(untpd.TypedSplice(methodRefTree), untpd.TypedSplice(qual) :: Nil))
            Inferencing.fullyDefinedType(convertedTree.tpe, "", pos)
        catch
          case error => conversionTarget.tree.tpe // fallback to not fully defined type

[rochala]

This PR needs a rewrite due to how type inference works in Scala 3.
In the snippet:

implicit class LUtil[T](xs: List[T]):
  def test1(x: T): List[T] = ???
extension [T](xs: List[T]) def test2(x: T): List[T] = ???

List(1,2,3).tes@@

The returned completions should be:
test1(x: T >: Int): List[T >: Int]
test2(x: T >: Int): List[T >: Int]

The reason behind it is that in Scala 3 type inference works on a whole application chain at the same time. So writing List(1, 2, 3).test("test") will compile and have type of List[Int | String]. It works that way only in apply chain, but in this issue, where completions don't have instantiated type vars it applies to both scenarios.

Both of them are basically chains:

List(1,2,3).test1("string") // LUtil[Int | String](List.apply[Int]([1, 2, 3 : Int]*)).test1("string")
List(1,2,3).test2("string") // test2[Int | String](List.apply[Int]([1, 2, 3 : Int]*))("string")

[rochala]

After consultations, I've come to conclusion that type vars should stay as they are so:

implicit class LUtil[T](xs: List[T]):
  def test1(x: T): List[T] = ???
extension [T](xs: List[T]) def test2(x: T): List[T] = ???

List(1,2,3).tes@@

should return test1(x: Int): List[Int]

[rochala]

After this PR, there will be another one that will make Ignored tests pass. I didn't want to make this one even bigger.

[kasiaMarek]

I feel like this would be a bit more readable if the cases were merged with completionSymbolKind. I'm guessing this part came from metals but this division feels a bit odd..

[jkciesluk]

Great job!
Some nitpicks, otherwise looks good.

[jkciesluk]

LGTM