Port TextInput-test.js to Fantom and remove the legacy Jest test

Summary:
Migrates the remaining meaningful coverage from `TextInput-test.js` (Jest with snapshots) over to `TextInput-itest.js` (Fantom) so we can rely on a single test file that exercises the real renderer instead of a heavily-mocked one.

Changes in `TextInput-itest.js`:
- Add a `focus()` test verifying that focusing a `TextInput` unfocuses any previously focused one (mirrors Jest's "should unfocus when other TextInput is focused").
- Add a top-level `has the correct displayName` test.
- Add a new set of `props` describes that assert the props from the original Jest snapshot tests reach the mounting layer via `getRenderedOutput({props: [...]}).toJSX()`:
  - \`id and nativeID\`: \`id\` → \`nativeID\` mapping, \`nativeID\` pass-through, and \`id\` precedence over \`nativeID\`.
  - \`testID\`: pass-through.
  - \`aria-label and accessibilityLabel\`: \`aria-label\` → \`accessibilityLabel\` mapping and \`accessibilityLabel\` pass-through.
  - \`aria-* and accessibilityState\`: \`aria-busy/checked/disabled/expanded/selected\` mapped into \`accessibilityState\`.
  - \`accessibilityRole\`: pass-through.
  - \`style\`: \`backgroundColor\` propagated as a native color value.

Tests intentionally NOT ported:
- Inherited \`HostInstance\` method presence checks (\`focus\`, \`blur\`, \`setNativeProps\`, \`measure\`, \`measureInWindow\`, \`measureLayout\`): they are guaranteed by Flow typing on \`ReactNativeElement\`, exercised in \`ReactNativeElement-itest.js\`, and Flow's \`method-unbinding\` rule prevents the simple \`toBeInstanceOf(Function)\` check without \`\$FlowFixMe\` (which is forbidden by project rules).
- \`focus() should not do anything if the TextInput is not editable\`: \`TextInputState.focusTextInput\` reads \`textField.currentProps?.editable\`, but in the new architecture \`currentProps\` is not exposed on the public \`ReactNativeElement\` instance, so the check is effectively bypassed. The Jest test only passed by monkey-patching \`currentProps\`. Documenting this as expected behavior in Fantom would mask a real bug.
- \`should give precedence to textContentType when set\`: \`textContentType\` is iOS-only and Fantom defaults to Android (\`AndroidTextInput\`).

Files removed:
- \`Libraries/Components/TextInput/__tests__/TextInput-test.js\`
- \`Libraries/Components/TextInput/__tests__/__snapshots__/TextInput-test.js.snap\`

Changelog: [Internal]

Differential Revision: D101977225

Author: rubennorte

packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-itest.js

@@ -148,6 +148,138 @@ describe('<TextInput>', () => {
         expect(blurEvent).toHaveBeenCalledTimes(1);
       });
     });
+
+    describe('id and nativeID', () => {
+      it(`has 'id' propagated as 'nativeID' to the mounting layer`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput id="alpha" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+
+      it(`has 'nativeID' propagated correctly`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput nativeID="alpha" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+
+      it(`has a precedence of 'id' over 'nativeID'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput id="alpha" nativeID="gamma" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+    });
+
+    describe('testID', () => {
+      it('is propagated to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput testID="my-test-id" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['testID']}).toJSX()).toEqual(
+          <rn-androidTextInput testID="my-test-id" />,
+        );
+      });
+    });
+
+    describe('aria-label and accessibilityLabel', () => {
+      it(`has 'aria-label' propagated as 'accessibilityLabel'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput aria-label="label" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityLabel']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityLabel="label" />);
+      });
+
+      it(`has 'accessibilityLabel' propagated correctly`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput accessibilityLabel="label" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityLabel']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityLabel="label" />);
+      });
+    });
+
+    describe('aria-* and accessibilityState', () => {
+      it(`maps 'aria-*' state props to 'accessibilityState'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(
+            <TextInput
+              aria-busy={true}
+              aria-checked={true}
+              aria-disabled={true}
+              aria-expanded={true}
+              aria-selected={true}
+            />,
+          );
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityState']}).toJSX(),
+        ).toEqual(
+          <rn-androidTextInput accessibilityState="{disabled:true,selected:true,checked:Checked,busy:true,expanded:true}" />,
+        );
+      });
+    });
+
+    describe('accessibilityRole', () => {
+      it('is propagated to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput accessibilityRole="button" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityRole']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityRole="button" />);
+      });
+    });
+
+    describe('style', () => {
+      it('propagates style values to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput style={{backgroundColor: 'white'}} />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['backgroundColor']}).toJSX(),
+        ).toEqual(
+          <rn-androidTextInput backgroundColor="rgba(255, 255, 255, 1)" />,
+        );
+      });
+    });
   });
 
   describe('ref', () => {
@@ -276,6 +408,43 @@ describe('<TextInput>', () => {
           'Command {type: "AndroidTextInput", nativeID: "text-input", name: "focus"}',
         ]);
       });
+
+      it('unfocuses any previously focused TextInput when a new one is focused', () => {
+        const root = Fantom.createRoot();
+        const ref1 = createRef<TextInputInstance>();
+        const ref2 = createRef<TextInputInstance>();
+
+        Fantom.runTask(() => {
+          root.render(
+            <>
+              <TextInput nativeID="text-input-1" ref={ref1} />
+              <TextInput nativeID="text-input-2" ref={ref2} />
+            </>,
+          );
+        });
+
+        const instance1 = nullthrows(ref1.current);
+        const instance2 = nullthrows(ref2.current);
+
+        expect(instance1.isFocused()).toBe(false);
+        expect(instance2.isFocused()).toBe(false);
+
+        Fantom.runTask(() => {
+          instance1.focus();
+        });
+
+        expect(instance1.isFocused()).toBe(true);
+        expect(instance2.isFocused()).toBe(false);
+        expect(TextInput.State.currentlyFocusedInput()).toBe(instance1);
+
+        Fantom.runTask(() => {
+          instance2.focus();
+        });
+
+        expect(instance1.isFocused()).toBe(false);
+        expect(instance2.isFocused()).toBe(true);
+        expect(TextInput.State.currentlyFocusedInput()).toBe(instance2);
+      });
     });
 
     describe('blur()', () => {
@@ -459,4 +628,8 @@ describe('<TextInput>', () => {
       });
     });
   });
+
+  it('has the correct displayName', () => {
+    expect(TextInput.displayName).toBe('TextInput');
+  });
 });