chore: organize solution into module folders (Core/Server/Drivers/Client/Tooling)

Group all 69 projects into category subfolders under src/ and tests/ so the
Rider Solution Explorer mirrors the module structure. Folders: Core, Server,
Drivers (with a nested Driver CLIs subfolder), Client, Tooling.

- Move every project folder on disk with git mv (history preserved as renames).
- Recompute relative paths in 57 .csproj files: cross-category ProjectReferences,
  the lib/ HintPath+None refs in Driver.Historian.Wonderware, and the external
  mxaccessgw refs in Driver.Galaxy and its test project.
- Rebuild ZB.MOM.WW.OtOpcUa.slnx with nested solution folders.
- Re-prefix project paths in functional scripts (e2e, compliance, smoke SQL,
  integration, install).

Build green (0 errors); unit tests pass. Docs left for a separate pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.IntegrationTests/OpcPlcFixture.cs

@@ -0,0 +1,97 @@
+using System.Net.Sockets;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.IntegrationTests;
+
+/// <summary>
+///     Reachability probe for an <c>opc-plc</c> simulator (Microsoft Industrial IoT's
+///     OPC UA PLC from <c>mcr.microsoft.com/iotedge/opc-plc</c>) or any real OPC UA
+///     server the <c>OPCUA_SIM_ENDPOINT</c> env var points at. Parses
+///     <c>OPCUA_SIM_ENDPOINT</c> (default <c>opc.tcp://localhost:50000</c>),
+///     TCP-connects to the resolved host:port at collection init, and records a
+///     <see cref="SkipReason"/> on failure. Tests call <c>Assert.Skip</c> on that, so
+///     `dotnet test` stays green when Docker isn't running the simulator — mirrors the
+///     <see cref="ModbusSimulatorFixture"/> / <c>Snap7ServerFixture</c> pattern.
+/// </summary>
+/// <remarks>
+///     <para>
+///         <b>Why opc-plc over loopback against our own server</b> — (1) independent
+///         cert chain + user-token handling catches interop bugs loopback can't;
+///         (2) built-in alarm ConditionType + history simulation gives
+///         <see cref="Core.Abstractions.IAlarmSource"/> +
+///         <see cref="Core.Abstractions.IHistoryProvider"/> coverage without a custom
+///         driver fake; (3) pinned image tag fixes the test surface in a way our own
+///         evolving server wouldn't. Follow-up: add <c>open62541/open62541</c> as a
+///         second image once this lands, for fully-independent-stack interop.
+///     </para>
+///     <para>
+///         Endpoint URL contract: parser strips the <c>opc.tcp://</c> scheme + resolves
+///         host + port for the liveness probe only. The real test session always
+///         dials the full endpoint URL via <see cref="OpcUaClientDriverOptions.EndpointUrl"/>
+///         so cert negotiation + security-policy selection run end-to-end.
+///     </para>
+/// </remarks>
+public sealed class OpcPlcFixture : IAsyncDisposable
+{
+    private const string DefaultEndpoint = "opc.tcp://localhost:50000";
+    private const string EndpointEnvVar = "OPCUA_SIM_ENDPOINT";
+
+    /// <summary>Full <c>opc.tcp://host:port</c> URL the driver session should connect to.</summary>
+    public string EndpointUrl { get; }
+    public string Host { get; }
+    public int Port { get; }
+    public string? SkipReason { get; }
+
+    public OpcPlcFixture()
+    {
+        EndpointUrl = Environment.GetEnvironmentVariable(EndpointEnvVar) ?? DefaultEndpoint;
+
+        (Host, Port) = ParseHostPort(EndpointUrl);
+
+        try
+        {
+            using var client = new TcpClient(AddressFamily.InterNetwork);
+            var task = client.ConnectAsync(
+                System.Net.Dns.GetHostAddresses(Host)
+                    .FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork)
+                    ?? System.Net.IPAddress.Loopback,
+                Port);
+            if (!task.Wait(TimeSpan.FromSeconds(2)) || !client.Connected)
+            {
+                SkipReason = $"opc-plc simulator at {Host}:{Port} did not accept a TCP connection within 2s. " +
+                             $"Start it (`docker compose -f Docker/docker-compose.yml up`) or override {EndpointEnvVar}.";
+            }
+        }
+        catch (Exception ex)
+        {
+            SkipReason = $"opc-plc simulator at {Host}:{Port} unreachable: {ex.GetType().Name}: {ex.Message}. " +
+                         $"Start it (`docker compose -f Docker/docker-compose.yml up`) or override {EndpointEnvVar}.";
+        }
+    }
+
+    /// <summary>
+    ///     Parse "opc.tcp://host:port[/path]" → (host, port). Defaults to port 4840
+    ///     (OPC UA standard) when the URL omits the port, but opc-plc's default is
+    ///     50000 so DefaultEndpoint carries it explicitly.
+    /// </summary>
+    private static (string Host, int Port) ParseHostPort(string endpointUrl)
+    {
+        const string scheme = "opc.tcp://";
+        var body = endpointUrl.StartsWith(scheme, StringComparison.OrdinalIgnoreCase)
+            ? endpointUrl[scheme.Length..]
+            : endpointUrl;
+        var slash = body.IndexOf('/');
+        if (slash >= 0) body = body[..slash];
+        var colon = body.IndexOf(':');
+        if (colon < 0) return (body, 4840);
+        var host = body[..colon];
+        return int.TryParse(body[(colon + 1)..], out var p) ? (host, p) : (host, 4840);
+    }
+
+    public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+}
+
+[Xunit.CollectionDefinition(Name)]
+public sealed class OpcPlcCollection : Xunit.ICollectionFixture<OpcPlcFixture>
+{
+    public const string Name = "OpcPlc";
+}