Fix FoldingReference.CompareTo antisymmetry for differing kinds

The Copilot PR reviewer noticed that when two references share the same
range but have different non-null `Kind`s, `CompareTo` fell through to
`return -1` for both `a.CompareTo(b)` and `b.CompareTo(a)`. That violates
the `IComparable` antisymmetry contract and can yield unstable ordering in
`Array.Sort`.

We now order differing non-null kinds deterministically with
`string.CompareOrdinal` over their string representations (stable LSP
values like `comment` and `region`), so the two directions always have
opposite signs. The null-vs-kind cases are unchanged: a reference without
a kind still sorts after one that has a kind.

Added a test asserting the comparison is antisymmetric for differing kinds.

Drafted by Copilot (Claude Opus 4.8).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: andyleejordan

src/PowerShellEditorServices/Services/TextDocument/FoldingReference.cs

@@ -60,20 +60,18 @@ public int CompareTo(FoldingReference that)
             if (EndCharacter < that.EndCharacter) { return -1; }
             if (EndCharacter > that.EndCharacter) { return 1; }
 
-            // They're the same range, but what about kind
-            if (Kind == that.Kind)
-            {
-                return 0;
-            }
-
-            // That has a kind but this doesn't.
-            if (Kind is null && that.Kind is not null)
-            {
-                return 1;
-            }
-
-            // This has a kind but that doesn't.
-            return -1;
+            // They're the same range, so now consider the kind. Equal kinds
+            // (including both null) compare as equal.
+            if (Kind == that.Kind) { return 0; }
+
+            // A reference without a kind sorts after one that has a kind.
+            if (Kind is null) { return 1; }
+            if (that.Kind is null) { return -1; }
+
+            // Both have a kind but they differ: order deterministically by their
+            // string representation so the comparison stays antisymmetric (i.e.
+            // a.CompareTo(b) and b.CompareTo(a) have opposite signs).
+            return string.CompareOrdinal(Kind.Value.ToString(), that.Kind.Value.ToString());
         }
 
         public bool Equals(FoldingReference other) => other is not null && CompareTo(other) == 0;

test/PowerShellEditorServices.Test/Language/FoldingReferenceEqualityTests.cs

@@ -67,5 +67,22 @@ public void EqualsDifferentTypeReturnsFalse()
             FoldingReference reference = CreateFoldingReference();
             Assert.False(reference.Equals("not a folding reference"));
         }
+
+        [Fact]
+        public void CompareToWithDifferingKindsIsAntisymmetric()
+        {
+            FoldingReference comment = CreateFoldingReference();
+            comment.Kind = FoldingRangeKind.Comment;
+            FoldingReference region = CreateFoldingReference();
+            region.Kind = FoldingRangeKind.Region;
+
+            // Same range but different (non-null) kinds must order
+            // deterministically: the comparisons must have opposite signs so
+            // Array.Sort stays stable. Previously both returned -1.
+            int forward = comment.CompareTo(region);
+            int backward = region.CompareTo(comment);
+            Assert.NotEqual(0, forward);
+            Assert.Equal(-System.Math.Sign(forward), System.Math.Sign(backward));
+        }
     }
 }