fix(linter/no-unused-vars): allow unused type params in ambient module blocks (#19615)

## What This PR Does

Fixes a bug in `eslint/no-unused-vars` where type parameters used in merged interfaces were marked as unused.

### Example
```ts
declare module 'bun:test' {
  // `T` is marked as unused, but removing it causes a type error.
  // This PR flags this param as allowed.
  interface Matchers<T> {
    toBeFoo(value: unknown): unknown;
  }
}
```

---------

Co-authored-by: Cameron Clark <cameron.clark@hey.com>

Author: DonIsaac

crates/oxc_linter/src/rules/eslint/no_unused_vars/allowed.rs

@@ -152,7 +152,43 @@ impl NoUnusedVars {
         symbol: &Symbol<'_, '_>,
         declaration_id: NodeId,
     ) -> bool {
-        matches!(symbol.nodes().parent_kind(declaration_id), AstKind::TSMappedType(_))
+        let nodes = symbol.nodes();
+        let scoping = symbol.scoping();
+
+        if matches!(nodes.parent_kind(declaration_id), AstKind::TSMappedType(_)) {
+            return true;
+        }
+
+        let is_interface_type_parameter = match nodes.parent_kind(declaration_id) {
+            AstKind::TSInterfaceDeclaration(_) => true,
+            AstKind::TSTypeParameterDeclaration(_) => {
+                matches!(
+                    nodes.parent_kind(nodes.parent_id(declaration_id)),
+                    AstKind::TSInterfaceDeclaration(_)
+                )
+            }
+            _ => false,
+        };
+        if !is_interface_type_parameter {
+            return false;
+        }
+
+        // type parameters used within type declarations in ambient ts module
+        // blocks are required for declaration merging to work, since signatures
+        // must match.
+        let Some(parent_scope_id) = scoping.scope_parent_id(symbol.scope_id()) else {
+            return false;
+        };
+        let scope_flags = scoping.scope_flags(parent_scope_id);
+        if scope_flags.is_ts_module_block() {
+            // get declaration node for the parent scope
+            let parent_node_id = scoping.get_node_id(parent_scope_id);
+            if let AstKind::TSModuleDeclaration(namespace) = nodes.get_node(parent_node_id).kind() {
+                return namespace.declare;
+            }
+        }
+
+        false
     }
 
     /// Returns `true` if this unused parameter should be allowed (i.e. not

crates/oxc_linter/src/rules/eslint/no_unused_vars/tests/oxc.rs

@@ -1246,9 +1246,28 @@ fn test_namespaces() {
         export { Foo }
         ",
         "declare module 'tsdown' { function bar(): void; }",
+        "
+        declare module 'vitest' {
+            interface Matchers<T> {
+                toBeFoo(value: unknown): unknown;
+            }
+        }
+        ",
     ];
 
-    let fail = vec!["namespace N {}", "export namespace N { function foo() }"];
+    let fail = vec![
+        "namespace N {}",
+        "export namespace N { function foo() }",
+        "
+        export namespace NonAmbientModuleDeclaration {
+            export interface Matchers<T> extends MatcherOverride {
+                toBeFoo(value: unknown): unknown;
+            }
+        }
+        ",
+        "declare module 'bun:test' { type Matchers2<T> = {} }",
+        "declare module 'bun:test' { class MyClass<T> {} }",
+    ];
 
     Tester::new(NoUnusedVars::NAME, NoUnusedVars::PLUGIN, pass, fail)
         .intentionally_allow_no_fix_tests()

crates/oxc_linter/src/snapshots/eslint_no_unused_vars@oxc-namespaces.snap

@@ -17,3 +17,37 @@ source: crates/oxc_linter/src/tester.rs
    ·                                ╰── 'foo' is declared here
    ╰────
   help: Consider removing this declaration.
+
+  ⚠ eslint(no-unused-vars): Variable 'T' is declared but never used. Unused variables should start with a '_'.
+   ╭─[no_unused_vars.tsx:3:39]
+ 2 │         export namespace NonAmbientModuleDeclaration {
+ 3 │             export interface Matchers<T> extends MatcherOverride {
+   ·                                       ┬
+   ·                                       ╰── 'T' is declared here
+ 4 │                 toBeFoo(value: unknown): unknown;
+   ╰────
+  help: Consider removing this declaration.
+
+  ⚠ eslint(no-unused-vars): Variable 'T' is declared but never used. Unused variables should start with a '_'.
+   ╭─[no_unused_vars.tsx:1:44]
+ 1 │ declare module 'bun:test' { type Matchers2<T> = {} }
+   ·                                            ┬
+   ·                                            ╰── 'T' is declared here
+   ╰────
+  help: Consider removing this declaration.
+
+  ⚠ eslint(no-unused-vars): Class 'MyClass' is declared but never used.
+   ╭─[no_unused_vars.tsx:1:35]
+ 1 │ declare module 'bun:test' { class MyClass<T> {} }
+   ·                                   ───┬───
+   ·                                      ╰── 'MyClass' is declared here
+   ╰────
+  help: Consider removing this declaration.
+
+  ⚠ eslint(no-unused-vars): Variable 'T' is declared but never used. Unused variables should start with a '_'.
+   ╭─[no_unused_vars.tsx:1:43]
+ 1 │ declare module 'bun:test' { class MyClass<T> {} }
+   ·                                           ┬
+   ·                                           ╰── 'T' is declared here
+   ╰────
+  help: Consider removing this declaration.