Add some more TypeVar-only test cases

Summary:
**This stack**

Adds a "callable residual" type that allows us to capture structure when a generic or overloaded callable is passed to a higher-order function. The residuals can later be "exploded" to recover generic and overload structure in outputs (either Callable outputs, or classes whose methods capture the callable structure of an argument - e.g. callback protocol classes).

The full design details are [here](https://github.com/stroxler/pyrefly-docs/tree/main/callable-residuals)

**This diff**

Agents, as they tend to do, implemented an initial solution to residual
handling that *shared absolutely no logic* with a correct answer but happened
to work on the test suite because all test cases involved an input that was
generic in a single type parameter that it returned.

This commit adds some more test cases where we have multiple type parameters
and/or the return type is concrete. This will make the test harness more robust
against completely incorrect implementations.

Reviewed By: rchen152

Differential Revision: D102011891

fbshipit-source-id: 8fcfab9052427d24a940c5c2a00dda9e485ef1be

Author: stroxler

pyrefly/lib/test/callable_residuals.rs

@@ -62,6 +62,34 @@ reveal_type(result)  # E: revealed type: (int, Unknown) -> Unknown
 "#,
 );
 
+testcase!(
+    bug = "Residual marker recovery incorrectly depends on return-position quantifieds",
+    test_generic_residual_concrete_return,
+    r#"
+from typing import Callable, reveal_type
+def higher_order[A, B](x: Callable[[A, B], int]) -> Callable[[A, B], int]:
+    return x
+def generic_fn[T](x: T, y: T) -> int:
+    return 0
+result = higher_order(generic_fn)
+reveal_type(result)  # E: revealed type: (Unknown, Unknown) -> int
+"#,
+);
+
+testcase!(
+    bug = "Distinct residual positions collapse to one solved variable in higher-order matching",
+    test_generic_residual_distinct_positions,
+    r#"
+from typing import Callable, reveal_type
+def higher_order[A, B](x: Callable[[A, B], B]) -> Callable[[A, B], B]:
+    return x
+def generic_fn[T, S](x: S, y: T) -> T:
+    return y
+result = higher_order(generic_fn)
+reveal_type(result)  # E: revealed type: (Unknown, Unknown) -> Unknown
+"#,
+);
+
 testcase!(
     bug = "Generic functions don't work with ParamSpec",
     test_param_spec_generic_function,