perf: close Theme 6 — 11 allocation / N+1 / lock-contention findings

Well-localised perf fixes across 8 modules.

Lock decoupling / SQL streaming:
- AuditLog-005: SqliteAuditWriter gains dedicated read-only _readConnection
  (+ _readLock) backed by WAL journal mode. GetBacklogStatsAsync,
  ReadPendingAsync, ReadPendingSinceAsync, ReadForwardedAsync no longer
  contend with the hot-path INSERT lock — backlog probes on a 30s timer
  can't stall the writer under multi-hundred-K Pending backlog.
- SEL-022: dropped Cache=Shared from SiteEventLogger's default connection
  string (single-connection logger; mode was dormant config).

Memory / streaming:
- CLI-019: bundle export streams base64 in 1 MB-aligned chunks via
  Convert.TryFromBase64Chars straight into the FileStream — no more
  full-bundle byte[] allocation.
- CentralUI-031: TransportImport now stages the upload to a per-session
  temp file under Path.GetTempPath() (replaces in-memory byte[] field);
  page implements IDisposable to delete the temp file on reset / new
  upload / dispose. Per-circuit working set drops from ~100 MB to ~80 KB.

N+1 hoisting:
- Transport-008: added ITemplateEngineRepository.GetTemplatesWithChildrenAsync
  bulk method; BundleImporter.PreviewAsync calls it once instead of per-
  template-name. Single query with .Include(...).AsSplitQuery().
- DM-023: BuildDeployArtifactsCommandAsync's per-site loop now references
  a pre-fetched GlobalArtifactSnapshot (shared scripts, external systems,
  DB connections, notification lists, SMTP) instead of re-querying per site.
- MgmtSvc-023: HandleQueryDeployments unfiltered branch uses one
  GetAllInstancesAsync bulk load + Dictionary<int,int?> lookup (was a
  GetInstanceByIdAsync per record).

Small allocations / per-tick rebuilds:
- InboundAPI-019: AuditWriteMiddleware gates EnableBuffering() on
  RequestHasBody() so GET/HEAD/DELETE/TRACE/OPTIONS and Content-Length:0
  requests skip the FileBufferingReadStream allocation.
- NotifOutbox-006: ResolveAdapters dictionary now cached on
  _adaptersCache (built lazily on first sweep) + actor-lifetime
  _adaptersScope; ResolveAdapters no longer rebuilds per dispatch tick.

Verify-only:
- Comm-017: Confirmed _inProgressDeployments was deleted by Comm-016 in
  commit ac96b83 — marked Resolved with that attribution. No code change.

Doc-correction:
- NS-022: Updated MailKitSmtpClientWrapper XML doc to spell out single-
  connection / per-delivery-factory contract (option (b) — transient
  client per Send — rejected because it re-handshakes TLS per email).

10+ new regression tests across 8 test projects. Build clean; affected
suites all green. README regenerated: 54 open (was 65).

src/ScadaLink.InboundAPI/Middleware/AuditWriteMiddleware.cs

@@ -138,9 +138,24 @@ public sealed class AuditWriteMiddleware
         // stream for a seekable wrapper that the framework rewinds at the end
         // of the pipeline for us — but we also rewind to position 0 after our
         // own read so the very next reader starts from the top.
-        ctx.Request.EnableBuffering();
-        var (requestBody, requestTruncated) =
-            await ReadBufferedRequestBodyAsync(ctx.Request, cap).ConfigureAwait(false);
+        //
+        // InboundAPI-019: skip EnableBuffering for bodyless requests (a known
+        // empty Content-Length or a method that conventionally carries no body —
+        // GET / HEAD / DELETE / TRACE / OPTIONS). The FileBufferingReadStream
+        // wrapper EnableBuffering installs allocates an internal buffer regardless
+        // of whether the request actually has a body; bodyless inbound traffic
+        // (e.g. GET /api/audit/query, health probes) no longer pays that cost.
+        // ReadBufferedRequestBodyAsync's own ContentLength is 0 short-circuit
+        // returns (null, false) for the bodyless case anyway, so the audit row
+        // is unchanged.
+        var requestBody = (string?)null;
+        var requestTruncated = false;
+        if (RequestHasBody(ctx.Request))
+        {
+            ctx.Request.EnableBuffering();
+            (requestBody, requestTruncated) =
+                await ReadBufferedRequestBodyAsync(ctx.Request, cap).ConfigureAwait(false);
+        }
 
         // Response body — wrap Response.Body in a forwarding stream that mirrors
         // every write to the original sink (transparent to the real client)
@@ -301,6 +316,31 @@ public sealed class AuditWriteMiddleware
             TaskScheduler.Default);
     }
 
+    /// <summary>
+    /// InboundAPI-019: decides whether the request is likely to carry a body, so the
+    /// caller can skip <see cref="HttpRequestRewindExtensions.EnableBuffering(HttpRequest)"/>
+    /// (and the associated <c>FileBufferingReadStream</c> allocation) on requests that
+    /// definitely won't have one. Returns <c>true</c> when <see cref="HttpRequest.ContentLength"/>
+    /// is positive OR when the HTTP method is one that conventionally carries a body
+    /// (POST / PUT / PATCH). Bodyless methods (GET / HEAD / DELETE / TRACE / OPTIONS)
+    /// with an absent or zero Content-Length return <c>false</c> — those are the
+    /// requests that previously paid the buffering allocation for no benefit. A
+    /// body-carrying method with no Content-Length (e.g. chunked transfer-encoding)
+    /// still buffers, so streamed POST bodies are unaffected.
+    /// </summary>
+    private static bool RequestHasBody(HttpRequest request)
+    {
+        if (request.ContentLength is > 0)
+        {
+            return true;
+        }
+
+        var method = request.Method;
+        return HttpMethods.IsPost(method)
+            || HttpMethods.IsPut(method)
+            || HttpMethods.IsPatch(method);
+    }
+
     /// <summary>
     /// Reads the buffered request body up to <paramref name="capBytes"/> bytes
     /// into a string for the audit copy and rewinds the stream so the