Add unit tests and logging infrastructure for InMemory and RabbitMQ transports

- Implemented RecordingLogger and RecordingLoggerFactory for capturing log entries in tests.
- Added unit tests for InMemoryChannel, covering constructor behavior, property assignments, channel communication, and disposal.
- Created InMemoryTransportOptionsTests to validate default values and customizable options for InMemory transport.
- Developed RabbitMqFrameProtocolTests to ensure correct parsing and property creation for RabbitMQ frames.
- Added RabbitMqTransportOptionsTests to verify default settings and customization options for RabbitMQ transport.
- Updated project files for testing libraries and dependencies.

src/__Libraries/__Tests/StellaOps.Router.Config.Tests/ConfigValidationResultTests.cs

@@ -0,0 +1,190 @@
+namespace StellaOps.Router.Config.Tests;
+
+/// <summary>
+/// Unit tests for <see cref="ConfigValidationResult"/>.
+/// </summary>
+public sealed class ConfigValidationResultTests
+{
+    #region Default Values Tests
+
+    [Fact]
+    public void Constructor_Errors_DefaultsToEmptyList()
+    {
+        // Arrange & Act
+        var result = new ConfigValidationResult();
+
+        // Assert
+        result.Errors.Should().NotBeNull();
+        result.Errors.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Constructor_Warnings_DefaultsToEmptyList()
+    {
+        // Arrange & Act
+        var result = new ConfigValidationResult();
+
+        // Assert
+        result.Warnings.Should().NotBeNull();
+        result.Warnings.Should().BeEmpty();
+    }
+
+    #endregion
+
+    #region IsValid Tests
+
+    [Fact]
+    public void IsValid_NoErrors_ReturnsTrue()
+    {
+        // Arrange
+        var result = new ConfigValidationResult();
+
+        // Act & Assert
+        result.IsValid.Should().BeTrue();
+    }
+
+    [Fact]
+    public void IsValid_WithErrors_ReturnsFalse()
+    {
+        // Arrange
+        var result = new ConfigValidationResult();
+        result.Errors.Add("Some error");
+
+        // Act & Assert
+        result.IsValid.Should().BeFalse();
+    }
+
+    [Fact]
+    public void IsValid_WithOnlyWarnings_ReturnsTrue()
+    {
+        // Arrange
+        var result = new ConfigValidationResult();
+        result.Warnings.Add("Some warning");
+
+        // Act & Assert
+        result.IsValid.Should().BeTrue();
+    }
+
+    [Fact]
+    public void IsValid_WithErrorsAndWarnings_ReturnsFalse()
+    {
+        // Arrange
+        var result = new ConfigValidationResult();
+        result.Errors.Add("Some error");
+        result.Warnings.Add("Some warning");
+
+        // Act & Assert
+        result.IsValid.Should().BeFalse();
+    }
+
+    [Fact]
+    public void IsValid_MultipleErrors_ReturnsFalse()
+    {
+        // Arrange
+        var result = new ConfigValidationResult();
+        result.Errors.Add("Error 1");
+        result.Errors.Add("Error 2");
+        result.Errors.Add("Error 3");
+
+        // Act & Assert
+        result.IsValid.Should().BeFalse();
+        result.Errors.Should().HaveCount(3);
+    }
+
+    #endregion
+
+    #region Static Success Tests
+
+    [Fact]
+    public void Success_ReturnsValidResult()
+    {
+        // Arrange & Act
+        var result = ConfigValidationResult.Success;
+
+        // Assert
+        result.IsValid.Should().BeTrue();
+        result.Errors.Should().BeEmpty();
+        result.Warnings.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Success_ReturnsNewInstance()
+    {
+        // Arrange & Act
+        var result1 = ConfigValidationResult.Success;
+        var result2 = ConfigValidationResult.Success;
+
+        // Assert - Should be different instances to allow mutation without affecting shared state
+        result1.Should().NotBeSameAs(result2);
+    }
+
+    #endregion
+
+    #region Errors Collection Tests
+
+    [Fact]
+    public void Errors_CanBeModified()
+    {
+        // Arrange
+        var result = new ConfigValidationResult();
+
+        // Act
+        result.Errors.Add("Error 1");
+        result.Errors.Add("Error 2");
+
+        // Assert
+        result.Errors.Should().HaveCount(2);
+        result.Errors.Should().Contain("Error 1");
+        result.Errors.Should().Contain("Error 2");
+    }
+
+    [Fact]
+    public void Errors_CanBeInitialized()
+    {
+        // Arrange & Act
+        var result = new ConfigValidationResult
+        {
+            Errors = ["Error 1", "Error 2"]
+        };
+
+        // Assert
+        result.Errors.Should().HaveCount(2);
+        result.IsValid.Should().BeFalse();
+    }
+
+    #endregion
+
+    #region Warnings Collection Tests
+
+    [Fact]
+    public void Warnings_CanBeModified()
+    {
+        // Arrange
+        var result = new ConfigValidationResult();
+
+        // Act
+        result.Warnings.Add("Warning 1");
+        result.Warnings.Add("Warning 2");
+
+        // Assert
+        result.Warnings.Should().HaveCount(2);
+        result.Warnings.Should().Contain("Warning 1");
+        result.Warnings.Should().Contain("Warning 2");
+    }
+
+    [Fact]
+    public void Warnings_CanBeInitialized()
+    {
+        // Arrange & Act
+        var result = new ConfigValidationResult
+        {
+            Warnings = ["Warning 1", "Warning 2"]
+        };
+
+        // Assert
+        result.Warnings.Should().HaveCount(2);
+        result.IsValid.Should().BeTrue(); // Warnings don't affect validity
+    }
+
+    #endregion
+}