Fix #18763: Run type inference before implicit search

[Alex1005a]

Fixes #18763
It seems that the problem is that searching for an instance of Functor[F] for the implicit conversion toFunctorOps tries all possible variants, because F is not constrained in any way. After failure in the case of AmbiguousImplicits, type inference occurs (F is constrained to IO) and the required instance is found. Inferring types before searching for an instance will help to avoid such cases.

[Alex1005a]

The fact that type inference only happens when an "ambiguous implicit" error occurs can lead to weird things.

import cats.effect.IO
import cats.implicits.*
import cats.effect.kernel.Async
import cats.Monad

case class SomeF[F[_], A]()

object SomeF {
  implicit def asyncForSomeF[F[_]](implicit F: Async[F]): Async[[A] =>> SomeF[F, A]] = ???

  implicit def monadForSomeF1[F[_]]: Monad[[A] =>> SomeF[F, A]] = ???

  implicit def monadForSomeF2[F[_]]: Monad[[A] =>> SomeF[F, A]] = ???

  def unit[F[_]]: SomeF[F, Unit] = SomeF()
}

val test: SomeF[IO, Unit] = toFunctorOps(SomeF.unit).as(???) // toFunctorOps can be omitted

In this code, for toFunctorOps the argument asyncForSomeF will be inferred. If you remove one of the Monad implicit, the remaining one will be inferred (for example, if you remove monadForSomeF2, then monadForSomeF1 will be inferred). If you remove both Monad implicit, then an error will be output that implicit not found.
If type inference was before implicit search, there would not be such strange behavior.