Pre-size intermediate Dictionary in ToFrozenDictionary

When the source is not already a Dictionary, ToFrozenDictionary builds
an intermediate Dictionary to deduplicate keys with last-wins semantics.
The previous code used the default-capacity constructor, which paid
log2(N) resizes and ~2N redundant rehashes when populating from a known
size source such as an array or List.

Use ICollection<KeyValuePair>.Count as a capacity hint when available,
mirroring the HashSet(IEnumerable, IEqualityComparer) constructor.
The ReadOnlySpan overload of FrozenDictionary.Create already pre-sizes,
so this brings the IEnumerable path in line with it.

Adds MultipleValuesSameKey_ICollectionSource_LastInWins regression test
to guard last-wins semantics over the pre-sized path.

Author: AndrewP-GH

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/FrozenDictionary.cs

@@ -131,7 +131,8 @@ public static FrozenDictionary<TKey, TElement> ToFrozenDictionary<TSource, TKey,
             newDictionary = source as Dictionary<TKey, TValue>;
             if (newDictionary is null || (newDictionary.Count != 0 && !newDictionary.Comparer.Equals(comparer)))
             {
-                newDictionary = new Dictionary<TKey, TValue>(comparer);
+                int capacity = source is ICollection<KeyValuePair<TKey, TValue>> collection ? collection.Count : 0;
+                newDictionary = new Dictionary<TKey, TValue>(capacity, comparer);
                 foreach (KeyValuePair<TKey, TValue> pair in source)
                 {
                     // Dictionary's constructor uses Add, which will throw on duplicates.

src/libraries/System.Collections.Immutable/tests/Frozen/FrozenDictionaryTests.cs

@@ -334,6 +334,31 @@ from value in values
             }
         }
 
+        [Fact]
+        public void MultipleValuesSameKey_ICollectionSource_LastInWins()
+        {
+            TKey[] keys = GenerateUniqueKeyValuePairs(2).Select(pair => pair.Key).ToArray();
+            TValue[] values = Enumerable.Range(0, 10).Select(CreateTValue).ToArray();
+
+            KeyValuePair<TKey, TValue>[] pairs =
+                (from key in keys
+                 from value in values
+                 select new KeyValuePair<TKey, TValue>(key, value)).ToArray();
+
+            foreach (IEnumerable<KeyValuePair<TKey, TValue>> source in new IEnumerable<KeyValuePair<TKey, TValue>>[]
+            {
+                pairs,
+                new List<KeyValuePair<TKey, TValue>>(pairs),
+            })
+            {
+                FrozenDictionary<TKey, TValue> frozen = source.ToFrozenDictionary(GetKeyIEqualityComparer());
+
+                Assert.Equal(values.Length, pairs.Length / keys.Length);
+                Assert.Equal(values[values.Length - 1], frozen[keys[0]]);
+                Assert.Equal(values[values.Length - 1], frozen[keys[1]]);
+            }
+        }
+
         [Theory]
         [InlineData(0)]
         [InlineData(1)]