Parametrized type alias union of callables unsubstitued using unannotated functions

Bug Report

A parametrized type alias of union of callable types doesn't substitute the type var parameters properly when using unannotated functions.

To Reproduce

from typing import Union, Callable, TypeVar, List


T = TypeVar("T")
T2 = TypeVar("T2")

F = Union[Callable[[T, int], T2], Callable[[T], T2]]


def foo(l: List[T], f: F[T, T2]) ->  T2:
    ...


reveal_type(foo([1, 2], lambda x: x + 1))  # Revealed type is "Any"
reveal_type(foo([1, 2], lambda x, y: x + y))  # Revealed type is "Any"

Expected Behavior

Both expressions in reveal_type should have builtins.int type as I think it has enough information to solve the type variables there.
As a workaround this works well:

from typing import List, Callable, TypeVar, overload


T = TypeVar("T")
T2 = TypeVar("T2")

@overload
def bar(l: List[T], f: Callable[[T, int], T2]) ->  T2:
    ...

@overload
def bar(l: List[T], f: Callable[[T], T2]) ->  T2:
    ...

def bar(l, f):
    ...

reveal_type(bar([1, 2], lambda x: x + 1))  # Revealed type is "builtins.int"
reveal_type(bar([1, 2], lambda x, y: x + y))  # Revealed type is "builtins.int"

But in my understanding I would expect the previous code to work the same

It also works fine with type annotated function:

from typing import Union, Callable, TypeVar, List


T = TypeVar("T")
T2 = TypeVar("T2")

F = Union[Callable[[T, int], T2], Callable[[T], T2]]


def foo(l: List[T], f: F[T, T2]) ->  T2:
    ...

def bar(x: int) -> int:
    ...

reveal_type(foo([1, 2], bar))  # Revealed type is "builtins.int"

Actual Behavior

Mypy doesn't substitute the type variables properly and reveal the type as Any

Your Environment

• Mypy version used: 0.991
• Mypy command-line flags: none
• Mypy configuration options from mypy.ini (and other config files): none
• Python version used: 3.11

Riproduci il problema con gli esempi forniti in Python 3.11 usando mypy 0.991 e conferma che entrambe le chiamate a lambda non annotate rivelano Any invece di int. Traccia la sostituzione della variabile di tipo per l’unione parametrizzata di tipi Callable, quindi aggiungi una copertura di regressione che mostri che entrambe le chiamate inferiscono builtins.int senza modificare il caso della funzione annotata.