perf: Write executeMount int buffer to Java in a single JNI call (#58692)

Summary:
`FabricMountingManager::executeMount` wrote the int buffer to Java with one `SetIntArrayRegion` per `writeInt`/`writeIntArray`, which is ~4.5k JNI calls for a commit that mounts 1500 views. The exact size is already known from `computeBufferSizes`, so this fills a `std::vector<jint>` instead and copies it once before `createIntBufferBatchMountItem`. The `int[]` Java receives is identical.

`GetPrimitiveArrayCritical` isn't an option here since the object writes call into Java between int writes, and on ART `GetIntArrayElements` copies movable arrays anyway.

Time spent in `executeMount` for one commit on an OPPO CPH2667 (Dimensity 6300, Android 16), release build. Each cell is the median over 114 commits from 6 interleaved runs:

| Commit | JNI calls | Before | After | Change |
|---|---|---|---|---|
| Remove 1500 views | 3004 → 1 | 2.14 ms | 1.88 ms | −12% |
| Add 1500 views | 4505 → 1 | 4.06 ms | 3.86 ms | −5% |
| Restyle 1500 views (size, padding, color) | 4505 → 1 | 5.25 ms | 5.04 ms | −4% |

The slowest commits improve more (e.g. 19.6 → 6.4 ms when restyling). The int transfer on its own goes from 174 → 87 µs per 1500-view commit. On an Apple silicon emulator JNI calls are ~5x cheaper and the difference is within noise.

## Changelog:

[ANDROID] [CHANGED] - Write Fabric mount instruction ints to Java in a single JNI call

Pull Request resolved: #58692

Test Plan:
- Built a variant that also fills a shadow `int[]` the old way and compares it with the array sent to Java on every commit: 1390 commits on device and 782 on emulator across Playground (1500 views), FlatList, Text and Image, 0 mismatches.
- RNTester (`yarn android` and release) on device and emulator: Playground, FlatList, Text and Image render as before.
- `yarn lint`, `yarn flow-check`, `yarn format-check-cpp` pass.
- Couldn't run `FabricMountingManagerTest` / `FabricMountingManagerInstrumentationTest`, they're Buck-only.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Reviewed By: javache

Differential Revision: D122059662

Pulled By: fabriziocucci

fbshipit-source-id: 60c548755c14d3c07963586215ad53be635870d3

Author: shubh73

packages/react-native/ReactAndroid/src/main/jni/react/fabric/FabricMountingManager.cpp

@@ -12,6 +12,7 @@
 #include "StateWrapperImpl.h"
 
 #include <cxxreact/TraceSection.h>
+#include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/jni/ReadableNativeArray.h>
 #include <react/jni/ReadableNativeMap.h>
@@ -359,22 +360,23 @@ jni::local_ref<jobject> getProps(
 }
 
 struct InstructionBuffer {
-  JNIEnv* env;
-  jintArray ints;
+  InstructionBuffer(int intsSize, int objectsSize)
+      : objects(jni::JArrayClass<jobject>::newArray(objectsSize)) {
+    ints.reserve(intsSize);
+  }
+
+  std::vector<jint> ints;
   jni::local_ref<jni::JArrayClass<jobject>> objects;
 
-  int intsPosition = 0;
   int objectsPosition = 0;
 
   inline void writeInt(int value) {
-    env->SetIntArrayRegion(ints, intsPosition, 1, &value);
-    intsPosition += 1;
+    ints.push_back(value);
   }
 
   template <size_t N>
   inline void writeIntArray(const std::array<int, N>& buffer) {
-    env->SetIntArrayRegion(ints, intsPosition, N, buffer.data());
-    intsPosition += N;
+    ints.insert(ints.end(), buffer.begin(), buffer.end());
   }
 
   inline void writeObject(jobject obj) {
@@ -862,11 +864,7 @@ void FabricMountingManager::executeMount(
 
   // Allocate the intBuffer and object array, now that we know exact sizes
   // necessary
-  InstructionBuffer buffer = {
-      .env = env,
-      .ints = env->NewIntArray(batchMountItemIntsSize),
-      .objects = jni::JArrayClass<jobject>::newArray(batchMountItemObjectsSize),
-  };
+  InstructionBuffer buffer(batchMountItemIntsSize, batchMountItemObjectsSize);
 
   // Fill in arrays
   int prevMountItemType = -1;
@@ -996,6 +994,13 @@ void FabricMountingManager::executeMount(
     }
   }
 
+  // Copy the ints to Java in a single JNI call, rather than one per write
+  react_native_assert(
+      static_cast<int>(buffer.ints.size()) == batchMountItemIntsSize);
+  jintArray ints = env->NewIntArray(static_cast<jsize>(buffer.ints.size()));
+  env->SetIntArrayRegion(
+      ints, 0, static_cast<jsize>(buffer.ints.size()), buffer.ints.data());
+
   static auto createMountItemsIntBufferBatchContainer =
       JFabricUIManager::javaClassStatic()
           ->getMethod<jni::alias_ref<JMountItem>(
@@ -1006,7 +1011,7 @@ void FabricMountingManager::executeMount(
       surfaceId,
       // If there are no items, we pass a nullptr instead of passing the
       // object through the JNI
-      batchMountItemIntsSize > 0 ? buffer.ints : nullptr,
+      batchMountItemIntsSize > 0 ? ints : nullptr,
       batchMountItemObjectsSize > 0 ? buffer.objects.get() : nullptr,
       revisionNumber);
 
@@ -1026,7 +1031,7 @@ void FabricMountingManager::executeMount(
       telemetry.getAffectedLayoutNodesCount(),
       static_cast<jboolean>(synchronous));
 
-  env->DeleteLocalRef(buffer.ints);
+  env->DeleteLocalRef(ints);
 }
 
 void FabricMountingManager::drainPreallocateViewsQueue() {