refactor: rename ScadaLink → ZB.MOM.WW.ScadaBridge (code + projects + namespaces)

Solution + 23 src projects + 26 test projects renamed; folders, csproj,
namespaces, and ScadaLinkDbContext/ScadaBridgeDbContext class updated.
ActorSystem "scadalink" → "scadabridge", Akka seed-node URLs migrated.
SQL roles/logins, LDAP domains, CLI command name, and CLI config dir
(~/.scadalink → ~/.scadabridge) also renamed.

Build green; 5 Host.Tests fail awaiting SQL login rename in next commit.
Pre-existing StaleTagMonitor timing flakes unchanged.

Rename script committed at tools/rename-to-scadabridge.sh.

src/ZB.MOM.WW.ScadaBridge.CentralUI/ScriptAnalysis/SandboxConsoleCapture.cs

@@ -0,0 +1,149 @@
+using System.Text;
+
+namespace ZB.MOM.WW.ScadaBridge.CentralUI.ScriptAnalysis;
+
+/// <summary>
+/// Per-call console capture for the Test Run sandbox.
+/// <para>
+/// Sandbox scripts use <c>System.Console.WriteLine</c> for ad-hoc output. The
+/// sandbox needs to capture that output per execution. <c>Console.Out</c> is,
+/// however, <b>process-global</b>: redirecting it with <c>Console.SetOut</c> for
+/// the duration of one run corrupts any other run executing concurrently —
+/// outputs interleave, and whichever run finishes first restores
+/// <c>Console.Out</c> while the others are still writing (CentralUI-003).
+/// </para>
+/// <para>
+/// This writer is installed into <c>Console.Out</c>/<c>Console.Error</c>
+/// <b>exactly once</b> (see <see cref="Install"/>) and never removed. Each
+/// concurrent run pushes its own buffer onto an <see cref="AsyncLocal{T}"/>
+/// scope via <see cref="BeginCapture"/>; writes on that run's logical call-tree
+/// land in that run's buffer only. Writes made on threads with no active
+/// capture scope (i.e. genuine host-process console output) fall through to the
+/// original writer. No process-global mutation happens per run.
+/// </para>
+/// </summary>
+internal sealed class SandboxConsoleCapture : TextWriter
+{
+    private static readonly object InstallLock = new();
+    private static SandboxConsoleCapture? _outInstance;
+    private static SandboxConsoleCapture? _errorInstance;
+
+    private readonly TextWriter _fallback;
+    private readonly AsyncLocal<StringWriter?> _current = new();
+
+    private SandboxConsoleCapture(TextWriter fallback) => _fallback = fallback;
+
+    /// <inheritdoc />
+    public override Encoding Encoding => _fallback.Encoding;
+
+    /// <summary>
+    /// Installs the routing writers into <see cref="Console.Out"/> and
+    /// <see cref="Console.Error"/> once for the process. Idempotent and
+    /// thread-safe. Subsequent calls return the already-installed instances.
+    /// </summary>
+    public static (SandboxConsoleCapture Out, SandboxConsoleCapture Error) Install()
+    {
+        if (_outInstance != null && _errorInstance != null)
+            return (_outInstance, _errorInstance);
+
+        lock (InstallLock)
+        {
+            if (_outInstance == null)
+            {
+                _outInstance = new SandboxConsoleCapture(Console.Out);
+                Console.SetOut(_outInstance);
+            }
+
+            if (_errorInstance == null)
+            {
+                _errorInstance = new SandboxConsoleCapture(Console.Error);
+                Console.SetError(_errorInstance);
+            }
+        }
+
+        return (_outInstance, _errorInstance);
+    }
+
+    /// <summary>
+    /// Begins a capture scope on the current logical (async) call-tree. All
+    /// console writes from this point until the returned scope is disposed are
+    /// routed into <paramref name="buffer"/> instead of the original writer.
+    /// The scope is restored on dispose, so nesting and concurrent scopes on
+    /// other call-trees are unaffected.
+    /// </summary>
+    /// <param name="buffer">The writer that receives console output for this scope.</param>
+    public CaptureScope BeginCapture(StringWriter buffer)
+    {
+        var previous = _current.Value;
+        _current.Value = buffer;
+        return new CaptureScope(this, previous);
+    }
+
+    // CentralUI-030: intra-script concurrency hardening. A sandboxed script
+    // can fan out work with `Task.WhenAll` / `Task.Run`; `AsyncLocal` flows
+    // the capture `StringWriter` into every child task, so two tasks can
+    // race the *same* buffer. `StringWriter` is not thread-safe — concurrent
+    // `Write`/`WriteLine` calls can corrupt the underlying `StringBuilder`
+    // and either throw or interleave at the character level. We lock on the
+    // captured writer itself so writes from one capture scope serialise;
+    // fall-through to the original `_fallback` (host-process console) is
+    // unlocked because the BCL's process-wide `Console.Out` is already
+    // synchronised by its TextWriter wrapper.
+    /// <inheritdoc />
+    public override void Write(char value) => WriteSynchronized(t => t.Write(value));
+
+    /// <inheritdoc />
+    public override void Write(string? value) => WriteSynchronized(t => t.Write(value));
+
+    /// <inheritdoc />
+    public override void Write(char[] buffer, int index, int count) =>
+        WriteSynchronized(t => t.Write(buffer, index, count));
+
+    /// <inheritdoc />
+    public override void WriteLine() => WriteSynchronized(t => t.WriteLine());
+
+    /// <inheritdoc />
+    public override void WriteLine(string? value) => WriteSynchronized(t => t.WriteLine(value));
+
+    /// <summary>
+    /// Routes a single write through the currently-active capture buffer
+    /// under a lock on that buffer, or to the unwrapped fallback writer when
+    /// no capture scope is active. The lock target is the `StringWriter`
+    /// instance itself — different capture scopes have different writers,
+    /// so two unrelated scopes never block each other.
+    /// </summary>
+    private void WriteSynchronized(Action<TextWriter> write)
+    {
+        var captured = _current.Value;
+        if (captured is null)
+        {
+            write(_fallback);
+            return;
+        }
+
+        lock (captured)
+        {
+            write(captured);
+        }
+    }
+
+    internal readonly struct CaptureScope : IDisposable
+    {
+        private readonly SandboxConsoleCapture _owner;
+        private readonly StringWriter? _previous;
+
+        /// <summary>
+        /// Initializes a capture scope that restores the previous writer on dispose.
+        /// </summary>
+        /// <param name="owner">The owning <see cref="SandboxConsoleCapture"/> instance.</param>
+        /// <param name="previous">The writer that was active before this scope was opened.</param>
+        internal CaptureScope(SandboxConsoleCapture owner, StringWriter? previous)
+        {
+            _owner = owner;
+            _previous = previous;
+        }
+
+        /// <summary>Restores the previous capture scope.</summary>
+        public void Dispose() => _owner._current.Value = _previous;
+    }
+}