[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.

Author: IDisposable

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

@@ -676,44 +676,43 @@ private static EnumFieldInfo[] TopologicalSortEnumFields(EnumFieldInfo[] enumFie
                 return enumFields;
             }
 
-            var indices = new int[enumFields.Length];
+            var indices = new long[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
+                int popCount = -PopCount(enumFields[i].Key);
+                // pack into a long with the pop count in the high bits and the index in the low bits
+                // this allows us to sort by pop count and then by index in case of ties
+                indices[i] = ((long)popCount << 32) | (uint)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 long, which is the low bits
+                // the high bits are the pop count, which we don't need anymore
+                int index = (int)(uint)indices[i];
+                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