Fixes #2716 .

Resolving method calls on implicit lambda parameters (e.g. a.getName() in
Comparator.comparing(a -> a.getName())) crashed with an
UnsupportedOperationException when the lambda was used inside a stream chain
on a user-defined element type.

Root cause

Comparator.comparing is a static generic method, so the scope-based type
parameter substitution that works for instance calls (e.g. stream.map(...))
is never taken. Its type parameter T therefore remained as an unresolved
TypeVariable, which caused two cascading failures:

1. LambdaExprContext.solveSymbolAsValue returned a constraint type whose
   bound was an unresolved TypeVariable T, and
2. AbstractJavaParserContext.findTypeDeclarations had no handler for that
   shape, throwing UnsupportedOperationException.
   Fix

LambdaExprContext.java — outer-context type parameter inference:
When the enclosing method call (e.g. comparing(...)) is itself an
argument of another method call with a known receiver type (e.g.
stream.sorted(...)), infer the static method's type parameters from the
outer call's expected parameter type. Concretely, the pair
(comparing's return type Comparator<T>) ↔ (sorted's expected type
Comparator<? super A>) is registered in the InferenceContext, letting
the engine resolve T → ? super A and thus determine the lambda
parameter type.
AbstractJavaParserContext.java — extended constraint-type handling in
findTypeDeclarations:
Added two new sub-cases inside the isConstraint() branch:

• isTypeVariable(): the bound is still an unresolved type variable
  (fallback when outer-context inference is unavailable); use the
  variable's explicit upper bounds, defaulting to Object.
• isWildcard() && isSuper(): the bound is ? super X produced by the
  outer-context inference; use X's type declaration (with the same
  TypeVariable fallback for X if needed).
  Tests

• LambdaExprContextResolutionTest: unit test verifying that
  solveSymbolAsValue("s") on the lambda in
  stream.sorted(Comparator.comparing(s -> s.toLowerCase())) returns
  ? super java.lang.String.
• LambdaResolutionTest: two integration tests — one asserting that all
  method calls in a stream chain with a user-defined element type resolve
  without throwing (direct regression for Cannot resolve sorted() in streams #2716), and one asserting the
  precise qualified signature of toLowerCase() when the element type is
  String.