[patch] Cover ContiguousMap.Entry equality and exclude benchmarks from Sonar

The SonarCloud quality gate failed on new_coverage (0% vs 80% required),
from exactly two uncovered new lines:

- Containers/ContiguousMap.cs - ContiguousMap<TKey,TValue>.Entry is a
  public struct with a full equality surface (Equals(Entry),
  Equals(object?), GetHashCode, == and !=) and had no tests at all.
  Added four tests covering equal/unequal entries, comparison against
  null and an unrelated type, and the Key/Value properties.

- Containers.Benchmarks - benchmark code is never executed by the test
  suite, so it can only ever report 0% coverage. Set SonarQubeExclude on
  the benchmark project.

Excluding the benchmark project also retires the 33 benchmark-only
findings that are artifacts of benchmark style rather than defects:
29x S3267 (identical foreach/counter loops kept uniform across competing
collections so the comparisons stay fair), 3x S4158 (operations on
intentionally-empty collections in EmptyCollectionOperations, plus a
foreach immediately after PushBack) and 1x S2583.

Build clean on all 8 TFMs, 355/355 tests pass.

Author: matt-edmondson

Containers.Benchmarks/Containers.Benchmarks.csproj

@@ -6,6 +6,15 @@
     <Nullable>enable</Nullable>
     <AssemblyName>Containers.Benchmarks</AssemblyName>
     <RootNamespace>ktsu.Containers.Benchmarks</RootNamespace>
+    <!--
+      Exclude the benchmark harness from SonarQube/SonarCloud analysis. Benchmarks are
+      deliberately written in a non-idiomatic style: explicit foreach/counter loops are kept
+      identical across competing collections so the comparisons stay fair, which Sonar reports
+      as S3267 ("use Where"), and operations on intentionally-empty collections read as S4158.
+      Benchmark code is also never executed by the test suite, so it can only ever drag the
+      new-code coverage gate to 0%. It is not shipped in the package.
+    -->
+    <SonarQubeExclude>true</SonarQubeExclude>
   </PropertyGroup>
 
   <ItemGroup>

Containers.Test/ContiguousMapTests.cs

@@ -525,4 +525,56 @@ public void HandlesNullValues()
 		Assert.IsTrue(map.TryGetValue(1, out string? value), "TryGetValue should return true for key with null value");
 		Assert.IsNull(value);
 	}
+
+	[TestMethod]
+	public void Entry_Equals_SameKeyAndValue_ReturnsTrue()
+	{
+		// Arrange
+		ContiguousMap<int, string>.Entry left = new(1, "one");
+		ContiguousMap<int, string>.Entry right = new(1, "one");
+
+		// Act & Assert
+		Assert.IsTrue(left.Equals(right), "Entries with the same key and value should be equal");
+		Assert.IsTrue(left.Equals((object)right), "Equals(object) should agree with Equals(Entry)");
+		Assert.IsTrue(left == right, "operator == should report equality");
+		Assert.IsFalse(left != right, "operator != should report equality");
+		Assert.AreEqual(left.GetHashCode(), right.GetHashCode());
+	}
+
+	[TestMethod]
+	public void Entry_Equals_DifferentKeyOrValue_ReturnsFalse()
+	{
+		// Arrange
+		ContiguousMap<int, string>.Entry entry = new(1, "one");
+		ContiguousMap<int, string>.Entry differentKey = new(2, "one");
+		ContiguousMap<int, string>.Entry differentValue = new(1, "two");
+
+		// Act & Assert
+		Assert.IsFalse(entry.Equals(differentKey), "Entries with different keys should not be equal");
+		Assert.IsFalse(entry.Equals(differentValue), "Entries with different values should not be equal");
+		Assert.IsTrue(entry != differentKey, "operator != should report inequality");
+		Assert.IsFalse(entry == differentValue, "operator == should report inequality");
+	}
+
+	[TestMethod]
+	public void Entry_Equals_NonEntryObject_ReturnsFalse()
+	{
+		// Arrange
+		ContiguousMap<int, string>.Entry entry = new(1, "one");
+
+		// Act & Assert
+		Assert.IsFalse(entry.Equals(null), "An entry should not equal null");
+		Assert.IsFalse(entry.Equals("not an entry"), "An entry should not equal an unrelated type");
+	}
+
+	[TestMethod]
+	public void Entry_KeyAndValue_ExposeConstructorArguments()
+	{
+		// Arrange & Act
+		ContiguousMap<int, string>.Entry entry = new(7, "seven");
+
+		// Assert
+		Assert.AreEqual(7, entry.Key);
+		Assert.AreEqual("seven", entry.Value);
+	}
 }