Inconsistent behavior for missing type variables in return slots

Bug Report

mypy behaves in an inconsistent fashion when revealing the type of an unconstrained type variable with no default when that variable appears in the return type of a function or method. When such type variables appear alone, mypy reports an error that return-slot type variables are not supported without a matching usage in the arguments or keyword arguments of the function or method being called. When combined using Union, however, missing type variables are silently coerced to Never without a warning or error being reported, leading to surprising applications of type narrowing.

To Reproduce

from typing import Any, Optional, cast, TypeVar, reveal_type

## Case 1: type variable in return position of function

def f[T]() -> T:
    raise Exception()

# mypy correctly refuses to type this, as it cannot infer T from the call site.
reveal_type(f())

## Case 2: type variable in return position of method

class C:
    def f[T](self) -> T:
        raise Exception()
    
# mypy correctly refuses to type this as well, and for the same reason.
reveal_type(C().f())

## Case 3: type variable in return position of method, combined with another
##         type

class D:
    def f[T](self) -> Optional[T]:
        raise Exception()
        
# mypy does not return an error or warning in this case, but substitutes
# `Never` for `T`, resulting in `Never | None` being narrowed to `None`.
reveal_type(D().f())

## Case 4: two type variables in return position of method, combined in a
##         type form


class E:
    def f[T, U](self) -> T | U:
        raise Exception()

# mypy also does not return an error or warning in this case, but substiutes
# `Never` for both `T` and `U`, resulting in `Never | Never` being narrowed
# to `Never`.
reveal_type(E().f())

## Case 5: type variable with explicit default=Any in return position of
##         function

U = TypeVar("U", default=Any)
def g[U]() -> U:
    raise Exception()

# Despite `U` having an explicit default, the definition of `g` returns an
# error, and `g()` is narrowed to `Never` instead of `Any`.
reveal_type(g)
reveal_type(g())

https://mypy-play.net/?mypy=latest&python=3.14&gist=044e1c85118dd1c92e110ee52c45d6e7

Expected Behavior

Either for mypy to return errors for D, E, and gin the same way asfandC`, or for substitution of type variable defaults to be applied uniformly when type variables cannot be inferred from call sites.

Actual Behavior

See above playground link.

Your Environment

mypy 1.19.1 on Python 3.14. See above playground link.

Start with the five reproductions in the issue or the linked mypy-playground example, focusing on return-slot type-variable inference and default substitution. The work is done when cases D, E, and g receive behavior consistent with f and C, with regression coverage for the reported reveal_type results.