fix: don't double-invoke effects for moved children in StrictMode

In StrictMode, `doubleInvokeEffectsInDEVIfNecessary` fires for any
fiber that has the `PlacementDEV` flag set. Previously, `placeChild`
set `PlacementDEV` on both newly inserted fibers AND fibers that were
moved to a different position in an array.

This caused a regression in React 19: when a keyed child is reordered
within an array, its effects are re-run in dev/StrictMode even when
dependencies are empty `[]`. The same component in production, or in
React 18, correctly skips effect re-runs for moves.

The fix is to only set `PlacementDEV` for actual insertions (where
`current === null`). Moved fibers (`current !== null`, `oldIndex <
lastPlacedIndex`) still receive the `Placement` flag so the host node
is correctly repositioned in the DOM, but StrictMode no longer treats
them as new mounts.

Also fix unused `ref3` variable in ReactFabric-test.internal.js
introduced in #35912 (copy-paste: third View used ref2 instead of ref3).

Fixes #32561

Author: emmaeng700

packages/react-native-renderer/src/__tests__/ReactFabric-test.internal.js

@@ -1215,7 +1215,7 @@ describe('ReactFabric', () => {
             }}
           />
           <View
-            ref={ref2}
+            ref={ref3}
             id="explicitTimeStampLowerCase"
             onTouchEnd={event => {
               expect(event.timeStamp).toBe(explicitTimeStampLowerCase);

packages/react-reconciler/src/ReactChildFiber.js

@@ -524,8 +524,11 @@ function createChildReconciler(
     if (current !== null) {
       const oldIndex = current.index;
       if (oldIndex < lastPlacedIndex) {
-        // This is a move.
-        newFiber.flags |= Placement | PlacementDEV;
+        // This is a move. The fiber already exists and is being repositioned in
+        // the DOM. We set Placement so the host node is moved, but we do NOT
+        // set PlacementDEV because the component is not newly mounting —
+        // StrictMode should not double-invoke effects for moved components.
+        newFiber.flags |= Placement;
         return lastPlacedIndex;
       } else {
         // This item can stay in place.

packages/react-reconciler/src/__tests__/StrictEffectsMode-test.js

@@ -964,4 +964,52 @@ describe('StrictEffectsMode', () => {
       'Child dep create',
     ]);
   });
+
+  it('should not double invoke effects when a keyed child is moved in an array', async () => {
+    const log = [];
+
+    function Item({id}) {
+      React.useEffect(() => {
+        log.push(`${id} effect mount`);
+        return () => log.push(`${id} effect unmount`);
+      }, []);
+
+      React.useLayoutEffect(() => {
+        log.push(`${id} layout mount`);
+        return () => log.push(`${id} layout unmount`);
+      }, []);
+
+      return id;
+    }
+
+    const root = ReactNoop.createRoot();
+
+    // Initial render: [A, B, C]
+    await act(() => {
+      root.render(
+        <React.StrictMode>
+          {['A', 'B', 'C'].map(id => (
+            <Item key={id} id={id} />
+          ))}
+        </React.StrictMode>,
+      );
+    });
+
+    log.length = 0; // clear mount logs, only care about what happens on reorder
+
+    // Reorder to [C, A, B] — all elements move but none are new
+    await act(() => {
+      root.render(
+        <React.StrictMode>
+          {['C', 'A', 'B'].map(id => (
+            <Item key={id} id={id} />
+          ))}
+        </React.StrictMode>,
+      );
+    });
+
+    // Moved elements should not have their effects re-run.
+    // Only DOM placement happens; no mount/unmount of effects.
+    expect(log).toEqual([]);
+  });
 });