fix(inbound-api): API-method recompile/invalidate reaches the peer central node; stale doc; locked-override name rule (ScadaBridge#103)

(a) Inbound API compile state (#75) is per central node: a recompile cleared the
known-bad record only on the node that answered, and the peer kept refusing the
unchanged script with SCRIPT_COMPILE_FAILED (the per-request revision check only
notices a changed script). Create / update / delete (ManagementActor post-commit),
RecompileApiMethod, and API methods written by a Transport bundle import now publish
InboundApiMethodInvalidated on the central cache-invalidation topic (#100 item 3).
The new InboundApiCacheInvalidationHandler drops that method's compiled handler,
known-bad record and cached ApiMethod row on the peer, which compiles the current
text on its next request.

(b) docs/components/InboundAPI.md no longer claims a direct DB edit stays stale
until restart: the per-request revision check picks it up once the node's cached
row expires (ApiMethodCacheTtl, 5 s). Component-InboundAPI, Component-Host and the
#85 cache audit describe the peer invalidation.

(c) Decision: the import's locked-override warnings keep EXACT (ordinal) name
matching, because FlatteningService matches override names ordinally. An override
differing from a locked member only by case never reaches that member's lock check
(the flattener drops it as unresolved), so a "targets a LOCKED member" warning for it
would be false. The comparer is now named (LockedOverrideNameComparer) and documented,
and pinned by tests on both sides (flattener + import).

Tests: the peer's known-bad record is cleared by a recompile (and validate leaves it
alone); create/update/delete and the import publish the invalidation; the handler
drops only the named method; composition root registers the handler; case-only
override gets no lock warning; the flattener matches override names exactly.

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

src/ZB.MOM.WW.ScadaBridge.ManagementService/ApiMethodCompileOperations.cs

@@ -2,6 +2,7 @@ using Microsoft.Extensions.DependencyInjection;
 using ZB.MOM.WW.ScadaBridge.Commons.Entities.InboundApi;
 using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
 using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
+using ZB.MOM.WW.ScadaBridge.Commons.Messages.Communication;
 using ZB.MOM.WW.ScadaBridge.Commons.Types.InboundApi;
 using ZB.MOM.WW.ScadaBridge.InboundAPI;
 
@@ -13,7 +14,8 @@ namespace ZB.MOM.WW.ScadaBridge.ManagementService;
 /// re-sent. Shared by the <see cref="ManagementActor"/> handlers (CLI / Management API) and
 /// the Central UI, which call it under the same role gate, so every surface reports the same
 /// thing. Compile state is per central node — each node compiles and caches independently —
-/// so every result names the node it came from.
+/// so every result names the node it came from. A recompile also drops the method's compile
+/// state on the peer central node (ScadaBridge#103), which recompiles on its next request.
 /// </summary>
 public static class ApiMethodCompileOperations
 {
@@ -36,7 +38,9 @@ public static class ApiMethodCompileOperations
     /// cached handler and clears the known-bad record, a failure records the new diagnostics
     /// (a previously working handler is never replaced by a failed compile, but the stored row
     /// stays authoritative, see <see cref="InboundScriptExecutor.CompileAndRegister(ApiMethod, out IReadOnlyList{string})"/>).
-    /// The node's cached row is dropped too, so the next request reads the stored row.
+    /// The node's cached row is dropped too, so the next request reads the stored row, and the
+    /// peer central node is told to drop its handler, known-bad record and cached row for the
+    /// method (ScadaBridge#103), so a recompile clears a stale compile failure on both nodes.
     /// Audited as <c>Recompile</c>.
     /// </summary>
     /// <param name="sp">The scoped service provider.</param>
@@ -48,6 +52,7 @@ public static class ApiMethodCompileOperations
         var method = await LoadAsync(sp, apiMethodId);
         var compiled = RequireExecutor(sp).CompileAndRegister(method, out var errors);
         sp.GetService<ApiMethodCache>()?.Invalidate(method.Name);
+        sp.GetService<ICentralCacheInvalidationPublisher>()?.Publish(new InboundApiMethodInvalidated(method.Name));
 
         var result = new ApiMethodCompileResult(method.Id, method.Name, compiled, errors, NodeName(sp));
         await sp.GetRequiredService<IAuditService>().LogAsync(

src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementActor.cs

@@ -3915,15 +3915,24 @@ public class ManagementActor : ReceiveActor
     /// <c>ApiMethodCacheTtl</c>: a just-deleted method stayed callable (the executor recompiled
     /// it from the cached row), and a cached not-found answered 404 for a just-created one.
     /// Queued post-commit, like the role-mapping invalidation, so a concurrent request cannot
-    /// re-cache the pre-change row. The peer central node still converges within the TTL
-    /// (default 5 s) — see <c>docs/plans/2026-11-09-central-cache-staleness-audit.md</c>.
+    /// re-cache the pre-change row. The peer central node is told with an
+    /// <see cref="InboundApiMethodInvalidated"/> on the central cache-invalidation topic
+    /// (ScadaBridge#103), which drops its row, compiled handler and known-bad record for the
+    /// method; the TTL (default 5 s) is only the fallback — see
+    /// <c>docs/plans/2026-11-09-central-cache-staleness-audit.md</c>.
     /// </summary>
     private static Task InvalidateApiMethodCacheAfterCommit(IServiceProvider sp, string name)
     {
         var cache = sp.GetService<InboundAPI.ApiMethodCache>();
-        return cache is null
+        var peers = sp.GetService<ICentralCacheInvalidationPublisher>();
+        return cache is null && peers is null
             ? Task.CompletedTask
-            : AfterConfigurationCommit(sp, () => { cache.Invalidate(name); return Task.CompletedTask; });
+            : AfterConfigurationCommit(sp, () =>
+            {
+                cache?.Invalidate(name);
+                peers?.Publish(new InboundApiMethodInvalidated(name));
+                return Task.CompletedTask;
+            });
     }
 
     /// <summary>