fix: recurse into nested type literals for computed property key detection

The computed property key collector only checked the top-level members of
a TSTypeLiteral but did not recurse into property type annotations. This
meant nested patterns like `{ nested: { [fromEmail]: string } }` would
miss inner computed keys, incorrectly eliding those imports.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/component/import_elision.rs

@@ -203,6 +203,14 @@ impl<'a> ImportElisionAnalyzer<'a> {
                         if prop_sig.computed {
                             Self::collect_idents_from_expr(&prop_sig.key, result);
                         }
+                        // Recurse into the property's type annotation to find
+                        // computed keys in nested type literals
+                        if let Some(type_ann) = &prop_sig.type_annotation {
+                            Self::collect_computed_keys_from_ts_type(
+                                &type_ann.type_annotation,
+                                result,
+                            );
+                        }
                     }
                 }
             }
@@ -1689,4 +1697,76 @@ class MyComponent {
             "RecipientType used as computed property key in type annotation should be preserved"
         );
     }
+
+    #[test]
+    fn test_nested_type_literal_computed_key_preserved() {
+        // Computed key inside a nested type literal: { nested: { [fromEmail]: string } }
+        let source = r#"
+import { Component, Input } from '@angular/core';
+import { fromEmail } from './email.interface';
+
+@Component({ selector: 'test' })
+class MyComponent {
+    @Input() config: {
+        nested: {
+            [fromEmail]: string;
+        };
+    };
+}
+"#;
+        let type_only = analyze_source(source);
+
+        assert!(
+            !type_only.contains("fromEmail"),
+            "fromEmail in nested type literal should be preserved"
+        );
+    }
+
+    #[test]
+    fn test_deeply_nested_type_literal_computed_key_preserved() {
+        // Computed key three levels deep
+        let source = r#"
+import { Component, Input } from '@angular/core';
+import { myKey } from './keys';
+
+@Component({ selector: 'test' })
+class MyComponent {
+    @Input() data: {
+        level1: {
+            level2: {
+                [myKey]: number;
+            };
+        };
+    };
+}
+"#;
+        let type_only = analyze_source(source);
+
+        assert!(
+            !type_only.contains("myKey"),
+            "myKey in deeply nested type literal should be preserved"
+        );
+    }
+
+    #[test]
+    fn test_computed_key_in_nested_union_type_literal_preserved() {
+        // Computed key inside a type literal nested within a union
+        let source = r#"
+import { Component, Input } from '@angular/core';
+import { myKey } from './keys';
+
+@Component({ selector: 'test' })
+class MyComponent {
+    @Input() data: {
+        field: { [myKey]: string } | null;
+    };
+}
+"#;
+        let type_only = analyze_source(source);
+
+        assert!(
+            !type_only.contains("myKey"),
+            "myKey in type literal nested within union should be preserved"
+        );
+    }
 }