Optimize ImmutableHashSet<T>.SetEquals to avoid unnecessary allocations

Author: Ahmed

src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs

@@ -743,6 +743,56 @@ private static bool SetEquals(IEnumerable<T> other, MutationInput origin)
         {
             Requires.NotNull(other, nameof(other));
 
+            if (other is ICollection<T> otherAsICollectionGeneric)
+            {
+                if (otherAsICollectionGeneric.Count < origin.Count)
+                {
+                    return false;
+                }
+                if (other is HashSet<T> otherAsHashSet)
+                {
+                    if (otherAsHashSet.Comparer == origin.EqualityComparer)
+                    {
+                        if (otherAsHashSet.Count != origin.Count)
+                        {
+                            return false;
+                        }
+                        foreach (T item in otherAsHashSet)
+                        {
+                            if (!Contains(item, origin))
+                            {
+                                return false;
+                            }
+                        }
+                        return true;
+                    }
+                }
+                else if (other is ImmutableHashSet<T> otherAsImmutableHashSet)
+                {
+                    if (otherAsImmutableHashSet.KeyComparer == origin.EqualityComparer)
+                    {
+                        if (otherAsImmutableHashSet.Count != origin.Count)
+                        {
+                            return false;
+                        }
+                        foreach (T item in otherAsImmutableHashSet)
+                        {
+                            if (!Contains(item, origin))
+                            {
+                                return false;
+                            }
+                        }
+                        return true;
+                    }
+                }
+            }
+            else if (other is ICollection otherAsICollection)
+            {
+                if (otherAsICollection.Count < origin.Count)
+                {
+                    return false;
+                }
+            }
             var otherSet = new HashSet<T>(other, origin.EqualityComparer);
             if (origin.Count != otherSet.Count)
             {