Add unit tests for Router configuration and transport layers

- Implemented tests for RouterConfig, RoutingOptions, StaticInstanceConfig, and RouterConfigOptions to ensure default values are set correctly.
- Added tests for RouterConfigProvider to validate configurations and ensure defaults are returned when no file is specified.
- Created tests for ConfigValidationResult to check success and error scenarios.
- Developed tests for ServiceCollectionExtensions to verify service registration for RouterConfig.
- Introduced UdpTransportTests to validate serialization, connection, request-response, and error handling in UDP transport.
- Added scripts for signing authority gaps and hashing DevPortal SDK snippets.

src/__Libraries/StellaOps.Microservice/RouterConnectionManager.cs

@@ -14,13 +14,16 @@ public sealed class RouterConnectionManager : IRouterConnectionManager, IDisposa
 {
     private readonly StellaMicroserviceOptions _options;
     private readonly IEndpointDiscoveryProvider _endpointDiscovery;
-    private readonly ITransportClient _transportClient;
+    private readonly IMicroserviceTransport? _microserviceTransport;
     private readonly ILogger<RouterConnectionManager> _logger;
     private readonly ConcurrentDictionary<string, ConnectionState> _connections = new();
     private readonly CancellationTokenSource _cts = new();
     private IReadOnlyList<EndpointDescriptor>? _endpoints;
     private Task? _heartbeatTask;
     private bool _disposed;
+    private volatile InstanceHealthStatus _currentStatus = InstanceHealthStatus.Healthy;
+    private int _inFlightRequestCount;
+    private double _errorRate;
 
     /// <inheritdoc />
     public IReadOnlyList<ConnectionState> Connections => [.. _connections.Values];
@@ -31,15 +34,42 @@ public sealed class RouterConnectionManager : IRouterConnectionManager, IDisposa
     public RouterConnectionManager(
         IOptions<StellaMicroserviceOptions> options,
         IEndpointDiscoveryProvider endpointDiscovery,
-        ITransportClient transportClient,
+        IMicroserviceTransport? microserviceTransport,
         ILogger<RouterConnectionManager> logger)
     {
         _options = options.Value;
         _endpointDiscovery = endpointDiscovery;
-        _transportClient = transportClient;
+        _microserviceTransport = microserviceTransport;
         _logger = logger;
     }
 
+    /// <summary>
+    /// Gets or sets the current health status reported by this instance.
+    /// </summary>
+    public InstanceHealthStatus CurrentStatus
+    {
+        get => _currentStatus;
+        set => _currentStatus = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the count of in-flight requests.
+    /// </summary>
+    public int InFlightRequestCount
+    {
+        get => _inFlightRequestCount;
+        set => _inFlightRequestCount = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the error rate (0.0 to 1.0).
+    /// </summary>
+    public double ErrorRate
+    {
+        get => _errorRate;
+        set => _errorRate = value;
+    }
+
     /// <inheritdoc />
     public async Task StartAsync(CancellationToken cancellationToken)
     {
@@ -168,32 +198,40 @@ public sealed class RouterConnectionManager : IRouterConnectionManager, IDisposa
             {
                 await Task.Delay(_options.HeartbeatInterval, cancellationToken);
 
-                foreach (var connection in _connections.Values)
+                // Build heartbeat payload with current status and metrics
+                var heartbeat = new HeartbeatPayload
+                {
+                    InstanceId = _options.InstanceId,
+                    Status = _currentStatus,
+                    InFlightRequestCount = _inFlightRequestCount,
+                    ErrorRate = _errorRate,
+                    TimestampUtc = DateTime.UtcNow
+                };
+
+                // Send heartbeat via transport
+                if (_microserviceTransport is not null)
                 {
                     try
                     {
-                        // Build heartbeat payload
-                        var heartbeat = new HeartbeatPayload
-                        {
-                            InstanceId = _options.InstanceId,
-                            Status = connection.Status,
-                            TimestampUtc = DateTime.UtcNow
-                        };
-
-                        // Update last heartbeat time
-                        connection.LastHeartbeatUtc = DateTime.UtcNow;
+                        await _microserviceTransport.SendHeartbeatAsync(heartbeat, cancellationToken);
 
                         _logger.LogDebug(
-                            "Sent heartbeat for connection {ConnectionId}",
-                            connection.ConnectionId);
+                            "Sent heartbeat: status={Status}, inflight={InFlight}, errorRate={ErrorRate:P1}",
+                            heartbeat.Status,
+                            heartbeat.InFlightRequestCount,
+                            heartbeat.ErrorRate);
                     }
                     catch (Exception ex)
                     {
-                        _logger.LogWarning(ex,
-                            "Failed to send heartbeat for connection {ConnectionId}",
-                            connection.ConnectionId);
+                        _logger.LogWarning(ex, "Failed to send heartbeat");
                     }
                 }
+
+                // Update connection state local heartbeat times
+                foreach (var connection in _connections.Values)
+                {
+                    connection.LastHeartbeatUtc = DateTime.UtcNow;
+                }
             }
             catch (OperationCanceledException)
             {