fix(scripting): name the script on the mirrored quarantine line; keep BadInternalError (lmxopcua#784)

(a) ScriptRunGuard logs its quarantine Error through the seam's script root
logger, which carries no ScriptName, so ScriptLogCompanionSink mirrored it to
the main log as "[Script] unknown emitted Error ..." and rate-limited every
quarantine on the node under one shared "unknown" key. The guard now binds the
script instance key as ScriptName (ForContext) on the quarantine Error and the
subscriber-threw Warning, so the mirror names the script and limits each one
separately. Test drives two real quarantines through the companion sink with a
1-per-window limiter: both mirrored, each named, none "unknown". Mutation-
checked: dropping the ForContext fails it.

(b) Evaluated a quarantine-specific OPC UA status (BadOutOfService) and kept
BadInternalError: it is the documented code for any script-attributable fault
on virtual tags, Calculation tags and scripted-alarm quality (and the
out-of-process runner design keeps it), BadOutOfService reads as a deliberately
disabled point, a new code is a ScadaBridge-visible contract change, and the
once-per-Good->Bad dedup means a timeout-driven quarantine would rarely show a
different code anyway. Documented in docs/VirtualTags.md ("Quarantine: what a
client sees"), with pointers from Calculation.md, ScriptedAlarms.md and the
OpcUaStatus.BadInternalError doc comment, plus where a quarantine IS visible.

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

tests/Core/ZB.MOM.WW.OtOpcUa.Core.Scripting.Tests/ScriptRunGuardTests.cs

@@ -1,3 +1,6 @@
+using Serilog;
+using Serilog.Core;
+using Serilog.Events;
 using Shouldly;
 using Xunit;
 using ZB.MOM.WW.OtOpcUa.Core.Scripting;
@@ -325,6 +328,46 @@ public sealed class ScriptRunGuardTests
         (await Run(guard, "ok", FastScript, fast, ct: ct)).ShouldBe(42);
     }
 
+    /// <summary>
+    ///     lmxopcua#784 — the quarantine Error reaches the main log through <see cref="ScriptLogCompanionSink"/>.
+    ///     The guard's logger is a seam's script root logger, which carries no ScriptName, so the mirror read
+    ///     "[Script] unknown emitted Error ..." and every quarantine on the node shared one "unknown" rate-limit
+    ///     key. The guard now binds the script instance key: the mirror names each script, and two scripts are
+    ///     rate-limited apart (with a budget of 1 per window, the second quarantine is still mirrored).
+    /// </summary>
+    [Fact]
+    public async Task The_quarantine_line_mirrored_to_the_main_log_names_the_script_and_is_rate_limited_per_script()
+    {
+        var mainSink = new CapturingSink();
+        var mainLogger = new LoggerConfiguration().MinimumLevel.Verbose().WriteTo.Sink(mainSink).CreateLogger();
+        var scriptRoot = new LoggerConfiguration()
+            .MinimumLevel.Verbose()
+            .WriteTo.Sink(new ScriptLogCompanionSink(mainLogger, limiter: new ScriptLogRateLimiter(1, TimeSpan.FromMinutes(5))))
+            .CreateLogger();
+        var guard = new ScriptRunGuard(new ScriptingOptions { QuarantineAfterConsecutiveTimeouts = 1 }, scriptRoot);
+        using var spin = Compile(SpinScript);
+        var ct = TestContext.Current.CancellationToken;
+
+        await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "vt-spin-a", SpinScript, spin, ShortTimeout, ct));
+        await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "vt-spin-b", SpinScript, spin, ShortTimeout, ct));
+
+        var mirrored = mainSink.Events.Select(e => e.RenderMessage()).ToList();
+        mirrored.Count.ShouldBe(2, string.Join(" | ", mirrored));
+        mirrored.ShouldAllBe(m => !m.Contains("unknown"));
+        mirrored.ShouldContain(m => m.Contains("vt-spin-a") && m.StartsWith("[Script] \"vt-spin-a\" emitted Error"));
+        mirrored.ShouldContain(m => m.Contains("vt-spin-b") && m.StartsWith("[Script] \"vt-spin-b\" emitted Error"));
+    }
+
+    private sealed class CapturingSink : ILogEventSink
+    {
+        public List<LogEvent> Events { get; } = [];
+
+        public void Emit(LogEvent logEvent)
+        {
+            lock (Events) Events.Add(logEvent);
+        }
+    }
+
     [Fact]
     public async Task A_disabled_allocation_budget_never_quarantines()
     {