[STJ] Optimize EnumFieldInfo sorting (#117839)

* [STJ] Only compute PopCount once when topologically sorting Enums

Packs the calculated (once per entry) PopCount into the high 32 bits of the long and the original index into the low 32 bits. Then that can just be sorted using the heavily optimized Array.Sort() method.
After sorting just extract the low 32 bits as the original array index. As before, we negate the actual _PopCount_ to ensure that `Key`s with more on-bits (e.g. more flags represented) will sort **first**.

This trades 2 x O(N log N) [average case] to 2 x O(N^2) [worst case] calls to the `popcount` instruction (or the emulation if NET is not defined) for N **shift-left-32** and **or** + N x **truncate to 32 bits**. It _also_ eliminates the overhead of the `CompareTo` method as it's now a direct `long` low-level compare.

* PR Feedback

Switched to Tuple

* PR Feedback
Switched to native tuple syntax
Co-authored-by: Pranav Senthilnathan <[email protected]>

* Update src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverter.cs

---------

Co-authored-by: Eirik Tsarpalis <[email protected]>

Author: IDisposable

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverter.cs

@@ -685,44 +685,40 @@ private static EnumFieldInfo[] TopologicalSortEnumFields(EnumFieldInfo[] enumFie
                 return enumFields;
             }
 
-            var indices = new int[enumFields.Length];
+            var indices = new (int negativePopCount, int index)[enumFields.Length];
             for (int i = 0; i < enumFields.Length; i++)
             {
-                indices[i] = i;
+                // We want values with more bits set to come first so negate the pop count.
+                // Keep the index as a second comparand so that sorting stability is preserved.
+                indices[i] = (-PopCount(enumFields[i].Key), i);
             }
 
-            Array.Sort(indices, (i, j) => GetComparisonKey(i).CompareTo(GetComparisonKey(j)));
+            Array.Sort(indices);
 
             var sortedFields = new EnumFieldInfo[enumFields.Length];
             for (int i = 0; i < indices.Length; i++)
             {
-                sortedFields[i] = enumFields[indices[i]];
+                // extract the index from the sorted tuple
+                int index = indices[i].index;
+                sortedFields[i] = enumFields[index];
             }
 
             return sortedFields;
+        }
 
-            (int PopCount, int Index) GetComparisonKey(int i)
-            {
-                // Sort by descending pop count of the enum value.
-                // Since Array.Sort isn't a stable algorithm
-                // append the current index to the comparison key.
-                return (-PopCount(enumFields[i].Key), i);
-            }
-
-            static int PopCount(ulong value)
-            {
+        private static int PopCount(ulong value)
+        {
 #if NET
-                return (int)ulong.PopCount(value);
+            return (int)ulong.PopCount(value);
 #else
-                int count = 0;
-                while (value != 0)
-                {
-                    value &= value - 1;
-                    count++;
-                }
-                return count;
-#endif
+            int count = 0;
+            while (value != 0)
+            {
+                value &= value - 1;
+                count++;
             }
+            return count;
+#endif
         }
 
         private enum EnumFieldNameKind