Resolver: Avoid intermediate allocations in matchSubpathFromMainFields, improve overall resolver perf ~5%

Summary:
`matchSubpathFromMainFields` is called on every resolution attempt (per source-extension via `redirectModulePath`, and per package entry point), and on every call it allocated a `.map()` array, a `.filter()` array, and an `Object.assign({}, ...spread)` - even in the overwhelmingly common case where the package declares no object-valued main field (no "browser" map) and the function returns `null`.

Instead, rebuild the merged replacement map with a single reverse loop over `mainFields` (preserving the prior "earlier mainFields win on key conflict" semantics) such that nothing is allocated (`null` is still returned) unless and until an object-valued field is actually found. The list of subpath variants is likewise only built in that rare matched case.

This improves the perf of `matchSubpathFromMainFields` by ~20% and ~5% on resolutions overall, based on Meta's product graph.

```
 - **[Performance]**: Refactor to reduce allocs for a ~5% faster resolver

Reviewed By: huntie

Differential Revision: D107024445

fbshipit-source-id: cec2261dc588590eb12bb413a7bbb6fc6869401c

Author: robhogan

packages/metro-resolver/src/PackageResolve.js

@@ -174,24 +174,36 @@ export function matchSubpathFromMainFields(
   pkg: PackageJson,
   mainFields: ReadonlyArray<string>,
 ): string | false | null {
-  const fieldValues = mainFields
+  // Merge object-valued main fields ("browser"-style maps) into a single
+  // replacement map. We iterate `mainFields` in reverse so that, on a key
+  // conflict, earlier `mainFields` win, equivalent to
+  // `Object.assign({}, ...fieldValues.reverse())`, but avoiding any allocation
+  // in the the most common case (no object-valued field, e.g. only a string
+  // "main"/"browser").
+  let replacements: {[string]: string | false} | null = null;
+  for (let i = mainFields.length - 1; i >= 0; i--) {
     // $FlowFixMe[invalid-computed-prop]
-    .map(name => pkg[name])
-    .filter(value => value != null && typeof value !== 'string');
+    const value = pkg[mainFields[i]];
+    if (value != null && typeof value !== 'string') {
+      if (replacements == null) {
+        replacements = {};
+      }
+      replacements = {...replacements, ...value};
+    }
+  }
 
-  if (!fieldValues.length) {
+  if (replacements == null) {
     return null;
   }
 
-  // $FlowFixMe[unsafe-object-assign]
-  const replacements = Object.assign({}, ...fieldValues.reverse());
+  // The list of subpath variants is only built in this rare matched case (a
+  // single subpath is expanded to its "browser"-spec variants; a pre-expanded
+  // array is matched as-is).
   const variants = Array.isArray(subpath)
     ? subpath
     : expandSubpathVariants(subpath);
-
   for (const variant of variants) {
     const replacement = replacements[variant];
-
     if (replacement != null) {
       return replacement;
     }