test(xml-tests): widen IConfiguration.VendorExtensions coverage on interface + mixed + namespace paths

Add four new assertions to the vendor-extension round-trip pinning surface:

- Interface contract — IConfiguration.VendorExtensions getter reflects the
  value set through the concrete Configuration.VendorExtensions setter,
  pinning the polymorphic projection.
- Mixed content — a Configuration carrying a standard Motion child AND a
  vendor extension round-trips through write + read with both slots
  populated. Exercises the branch of XmlConfiguration.ToConfiguration
  where strongly-typed children and vendor-namespaced children coexist.
- Nested attribute preservation — extensions with attributes on both the
  root element AND nested descendants round-trip verbatim through the
  WriteRaw / XElement.Parse(LoadOptions.PreserveWhitespace) pipeline.
- Distinct vendor namespaces — two extensions from different vendor
  namespaces keep their bindings and are distinguished by fully-qualified
  XName, not local name alone.

Claude-Session: https://claude.ai/code/session_0162RfaA55VT8NX6QfU7RUVo

Author: ottobolyos

tests/MTConnect.NET-XML-Tests/Devices/Configurations/ConfigurationVendorExtensionsRoundTripTests.cs

@@ -313,5 +313,150 @@ public void Write_emits_no_extension_when_VendorExtensions_is_all_nulls()
                 xml,
                 Is.EqualTo("<Configuration />").Or.EqualTo("<Configuration></Configuration>"));
         }
+
+        // ---------------- interface contract ----------------
+
+        /// <summary>The <see cref="IConfiguration.VendorExtensions"/> interface
+        /// getter reflects the value set through the concrete
+        /// <see cref="Configuration.VendorExtensions"/> setter — the
+        /// polymorphic surface projects the concrete slot without a
+        /// separate backing field.</summary>
+        [Test]
+        public void IConfiguration_VendorExtensions_getter_reflects_concrete_setter()
+        {
+            var payload = new[]
+            {
+                XElement.Parse("<v:V xmlns:v=\"urn:v\">payload</v:V>")
+            };
+            IConfiguration configuration = new Configuration
+            {
+                VendorExtensions = payload
+            };
+
+            Assert.That(configuration.VendorExtensions, Is.SameAs(payload));
+        }
+
+        // ---------------- mixed content ----------------
+
+        /// <summary>A <c>Configuration</c> that carries a standard
+        /// <c>Motion</c> child AND a vendor extension round-trips through
+        /// write + read with both slots populated. Pins the branch of
+        /// <see cref="XmlConfiguration.ToConfiguration"/> where standard
+        /// children AND vendor-namespaced children coexist inside the
+        /// same envelope.</summary>
+        [Test]
+        public void Round_trip_preserves_standard_child_and_vendor_extension_together()
+        {
+            var original = new Configuration
+            {
+                Motion = new Motion
+                {
+                    Id = "m1",
+                    Type = MotionType.PRISMATIC,
+                    Actuation = MotionActuationType.DIRECT,
+                    Axis = new Axis { Value = "1 2 3" }
+                },
+                VendorExtensions = new[]
+                {
+                    XElement.Parse(
+                        "<vendor:Custom xmlns:vendor=\"urn:vendor:mtconnect\" "
+                        + "id=\"custom-1\">"
+                        + "<Payload>ping</Payload>"
+                        + "</vendor:Custom>")
+                }
+            };
+
+            var xml = XmlRoundTripHelper.Write(w =>
+                XmlConfiguration.WriteXml(w, original, outputComments: false));
+            var wire = XmlRoundTripHelper.Read<XmlConfiguration>(xml);
+            var round = wire.ToConfiguration();
+
+            Assert.That(round.Motion, Is.Not.Null);
+            Assert.That(round.Motion!.Id, Is.EqualTo("m1"));
+
+            Assert.That(round.VendorExtensions, Is.Not.Null);
+            var extensions = round.VendorExtensions.ToList();
+            Assert.That(extensions, Has.Count.EqualTo(1));
+            Assert.That(extensions[0].Name.LocalName, Is.EqualTo("Custom"));
+            Assert.That(extensions[0].Attribute("id")?.Value, Is.EqualTo("custom-1"));
+            Assert.That(extensions[0].Element("Payload")?.Value, Is.EqualTo("ping"));
+        }
+
+        // ---------------- attribute + text preservation ----------------
+
+        /// <summary>Vendor extensions with attributes on both the root element
+        /// AND nested descendants round-trip verbatim — the <c>WriteRaw</c>
+        /// path on the write side and <c>XElement.Parse</c> with
+        /// <see cref="LoadOptions.PreserveWhitespace"/> on the read side
+        /// preserve the authored structure.</summary>
+        [Test]
+        public void Round_trip_preserves_nested_attributes_verbatim()
+        {
+            var original = new Configuration
+            {
+                VendorExtensions = new[]
+                {
+                    XElement.Parse(
+                        "<vendor:Ext xmlns:vendor=\"urn:vendor\" rootAttr=\"1\">"
+                        + "<Child childAttr=\"A\" order=\"first\">alpha</Child>"
+                        + "<Child childAttr=\"B\" order=\"second\">beta</Child>"
+                        + "</vendor:Ext>")
+                }
+            };
+
+            var xml = XmlRoundTripHelper.Write(w =>
+                XmlConfiguration.WriteXml(w, original, outputComments: false));
+            var wire = XmlRoundTripHelper.Read<XmlConfiguration>(xml);
+            var round = wire.ToConfiguration();
+
+            var extensions = round.VendorExtensions.ToList();
+            Assert.That(extensions, Has.Count.EqualTo(1));
+            var ext = extensions[0];
+
+            Assert.That(ext.Attribute("rootAttr")?.Value, Is.EqualTo("1"));
+            var children = ext.Elements("Child").ToList();
+            Assert.That(children, Has.Count.EqualTo(2));
+            Assert.That(children[0].Attribute("childAttr")?.Value, Is.EqualTo("A"));
+            Assert.That(children[0].Attribute("order")?.Value, Is.EqualTo("first"));
+            Assert.That(children[0].Value, Is.EqualTo("alpha"));
+            Assert.That(children[1].Attribute("childAttr")?.Value, Is.EqualTo("B"));
+            Assert.That(children[1].Attribute("order")?.Value, Is.EqualTo("second"));
+            Assert.That(children[1].Value, Is.EqualTo("beta"));
+        }
+
+        // ---------------- multiple vendors, distinct namespaces ----------------
+
+        /// <summary>Two vendor extensions from distinct vendor namespaces
+        /// round-trip independently — each keeps its own namespace binding,
+        /// and the deserialiser distinguishes them by fully-qualified
+        /// <see cref="XName"/> rather than by local name alone.</summary>
+        [Test]
+        public void Round_trip_preserves_distinct_vendor_namespaces()
+        {
+            var original = new Configuration
+            {
+                VendorExtensions = new[]
+                {
+                    XElement.Parse(
+                        "<v1:Ext xmlns:v1=\"urn:vendor-one\">one</v1:Ext>"),
+                    XElement.Parse(
+                        "<v2:Ext xmlns:v2=\"urn:vendor-two\">two</v2:Ext>")
+                }
+            };
+
+            var xml = XmlRoundTripHelper.Write(w =>
+                XmlConfiguration.WriteXml(w, original, outputComments: false));
+            var wire = XmlRoundTripHelper.Read<XmlConfiguration>(xml);
+            var round = wire.ToConfiguration();
+
+            var extensions = round.VendorExtensions.ToList();
+            Assert.That(extensions, Has.Count.EqualTo(2));
+            Assert.That(extensions[0].Name.NamespaceName, Is.EqualTo("urn:vendor-one"));
+            Assert.That(extensions[0].Name.LocalName, Is.EqualTo("Ext"));
+            Assert.That(extensions[0].Value, Is.EqualTo("one"));
+            Assert.That(extensions[1].Name.NamespaceName, Is.EqualTo("urn:vendor-two"));
+            Assert.That(extensions[1].Name.LocalName, Is.EqualTo("Ext"));
+            Assert.That(extensions[1].Value, Is.EqualTo("two"));
+        }
     }
 }