Fix compiler crash on JSX overload resolution failure reported by #61524

Replace `Debug.fail()` calls with proper error generation to prevent TypeScript
compiler crashes when overload resolution fails for JSX elements with complex
generic constraints.

Problem
--

The TypeScript compiler crashes with "Debug Failure. No error for last overload
signature" when resolving certain JSX element types. This regression has existed
since TypeScript 3.6 and affects many React/JSX projects.

Root Cause
--

When `getSignatureApplicabilityError()` returns no diagnostics for overload
candidates, the compiler calls `Debug.fail()` instead of handling the edge case
gracefully, causing an immediate crash.

Solution
--

- Replace `Debug.fail()` calls with fallback diagnostic generation
- Generate appropriate error messages for unhandled overload resolution cases
- Ensure compiler continues execution without crashing

Related to #61524, #60229, #48636, #33133

Signed-off-by: moznion <moznion@mail.moznion.net>

Author: moznion

src/compiler/checker.ts

@@ -36603,7 +36603,22 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         }
                     }
                     else {
-                        Debug.fail("No error for last overload signature");
+                        // Fallback: Generate a generic error when no specific error can be determined
+                        // This replaces the Debug.fail() to prevent compiler crashes
+                        // See: https://github.com/microsoft/TypeScript/issues/61524
+                        const fallbackChain = chainDiagnosticMessages(
+                            /*details*/ undefined,
+                            Diagnostics.No_overload_matches_this_call
+                        );
+                        const errorNode = getErrorNodeForCallNode(node);
+                        const fallbackDiag = createDiagnosticForNodeFromMessageChain(
+                            getSourceFileOfNode(errorNode),
+                            errorNode,
+                            fallbackChain,
+                            /*relatedInformation*/ undefined
+                        );
+
+                        diagnostics.add(fallbackDiag);
                     }
                 }
                 else {
@@ -36624,7 +36639,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                             allDiagnostics.push(diags);
                         }
                         else {
-                            Debug.fail("No error for 3 or fewer overload signatures");
+                            // Fallback: Generate a generic error for this overload candidate
+                            // This prevents crashes when processing multiple overload signatures
+                            const fallbackChain = chainDiagnosticMessages(
+                                /*details*/ undefined,
+                                Diagnostics.Overload_0_of_1_2_gave_the_following_error,
+                                i + 1,
+                                candidates.length,
+                                signatureToString(c)
+                            );
+                            const errorNode = getErrorNodeForCallNode(node);
+                            const fallbackDiag = createDiagnosticForNodeFromMessageChain(
+                                getSourceFileOfNode(errorNode),
+                                errorNode,
+                                fallbackChain,
+                                /*relatedInformation*/ undefined
+                            );
+                            allDiagnostics.push([fallbackDiag]);
                         }
                         i++;
                     }