Fix widen types before checking an implicit view exists

It's not possible to convert a method, such as a polymorphic method,
such as `makeChurch`, into another type - we need to widen out the
TermRef to discover the underlying PolyType which isn't a value type.
Failing to do so will create a dummyTreeOfType, which will then be
attempted to be applied, which eventually causes an assertion crash
while building the tpd.TypeApply.

[Cherry-picked 8a2773f]

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

@@ -825,7 +825,7 @@ trait Implicits:
     && !to.isError
     && !ctx.isAfterTyper
     && ctx.mode.is(Mode.ImplicitsEnabled)
-    && from.isValueType
+    && from.widen.isValueType
     && (  from.isValueSubType(to)
        || inferView(dummyTreeOfType(from), to)
             (using ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState()).isSuccess

tests/neg/i18650.min.scala

@@ -0,0 +1,8 @@
+class Church[B]:
+  type Nat = Tuple1[B]
+
+class Test:
+  given makeChurch[C]: Church[C] = ??? // necessary to cause crash
+
+  def churchTest(c: Church[Int]): Unit =
+    val res1 = summon[c.Nat =:= Int] // error (not a compiler crash)

tests/neg/i18650.min2.scala

@@ -0,0 +1,8 @@
+class Church[B]:
+  type Nat = Tuple1[B]
+
+class Test2:
+  given makeChurch2[C](using DummyImplicit): Church[C] = ???
+
+  def churchTest2(c: Church[Int]): Unit =
+    val res2 = summon[c.Nat =:= Int] // error (not a compiler crash)

tests/neg/i18650.scala

@@ -0,0 +1,26 @@
+trait Lam:
+  type F[_]
+  extension [A, B](f: F[A => B]) def apply(arg: F[A]): F[B]
+  def lam[A, B](f: F[A] => F[B]): F[A => B]
+  final def id[A]: F[A => A] = lam(identity[F[A]])
+
+object LamInterpreter extends Lam:
+  type F[t] = t
+  def lam[A, B](f: F[A] => F[B]): F[A => B] = f
+  extension [A, B](f: F[A => B]) def apply(arg: F[A]): F[B] = f(arg)
+
+
+class Church[A](using val l: Lam):
+  import l.*
+  type Nat = F[(A => A) => (A => A)]
+  def zero: Nat = id
+  extension (n: Nat) def suc: Nat = lam(f => lam(x => f(n(f)(x))))
+
+given [A](using l: Lam): Church[A] = Church()
+
+
+@main
+def churchTest =
+  given Lam = LamInterpreter
+  val c: Church[Int] = summon
+  summon[c.Nat =:= ((Int => Int) => (Int => Int))] // error (not a compiler crash)