feat(ui/scripts): format, inlay hints, problems panel, type diagnostic

Three more editor features rolled in:

1. Roslyn Format command.
   New POST /api/script-analysis/format runs Formatter.Format() from
   Microsoft.CodeAnalysis.CSharp.Workspaces on the parsed script
   tree. monaco-init.js registers a DocumentFormattingEditProvider
   so Ctrl/Cmd-Shift-F and the toolbar "Format" button both work.

2. Inlay hints with parameter names.
   New POST /api/script-analysis/inlay-hints walks CallShared /
   CallScript invocations and emits InlayHint records positioned at
   each argument with the matching parameter's name (e.g. "name:").
   Ghost text appears via Monaco's InlayHintsProvider.

3. SCADA005 argument-type diagnostic.
   Literal type vs. declared parameter type check on every
   CallShared/CallScript argument. Float accepts Integer literals;
   Object/List accept anything; null only matches reference-ish
   types. Legacy lowercase types ("string" etc) from the DB are
   normalized to the canonical set before comparison so existing
   data doesn't false-negative. Non-literal args (variables,
   expressions) are skipped — out of scope for a cheap pass.

4. Parameters["name"] hover.
   Hover endpoint now also resolves Parameters["X"] element-access
   keys against the form's DeclaredParameterShapes and returns
   "parameter `name: String`"-style markdown. MonacoEditor surfaces
   the new DeclaredParameterShapes parameter; ScriptParameterNames
   gets a ParseShapes companion.

5. Problems panel.
   Bootstrap card under the editor listing every marker with
   severity badge, line number, message, and SCADA / CS code. Click
   a row to scroll the editor to that line and focus. JS now
   invokes OnMarkersChanged on the .NET side whenever
   setModelMarkers fires, so the panel stays in sync with the
   editor.

6. Editor toolbar.
   Small top-right strip on each editor with Format / Wrap /
   Minimap / Theme toggles. New MonacoBlazor.format,
   setEditorOption, and revealLine JS APIs back the buttons and the
   problems-panel scroll-to-line.

Contracts:
  - FormatRequest / FormatResponse
  - InlayHintsRequest / InlayHintsResponse / InlayHint
  - HoverRequest.DeclaredParameters
  - MonacoEditor.DeclaredParameterShapes parameter
  - MonacoEditor.MarkersChanged callback
  - ScadaContext.DeclaredParameterShapes

10 new xUnit tests covering format, inlay hints, SCADA005 (string-
expects-integer, integer-expects-string, float-accepts-integer,
object-accepts-anything, non-literal-skipped), and Parameters key
hover. Total: 139 -> 149.

Microsoft.CodeAnalysis.CSharp.Workspaces 4.13.0 added to pull in
Formatter and AdhocWorkspace.

Browser-verified: typing `CallShared("Greet", 42)` now shows the
"name:" inlay hint and a SCADA005 squiggle on `42`; Parameters["typo"]
shows SCADA003 as before; the toolbar buttons all work.

src/ScadaLink.CentralUI/Components/Shared/MonacoEditor.razor

@@ -2,6 +2,20 @@
 @implements IAsyncDisposable
 @inject IJSRuntime JS
 
+@if (ShowToolbar)
+{
+    <div class="d-flex justify-content-end align-items-center gap-3 mb-1 small text-muted">
+        <button type="button" class="btn btn-link btn-sm p-0 text-decoration-none" @onclick="FormatAsync"
+                title="Format document (Ctrl/Cmd+Shift+F)">Format</button>
+        <button type="button" class="btn btn-link btn-sm p-0 text-decoration-none" @onclick="ToggleWrap"
+                title="Word wrap">@(_wrap ? "Wrap on" : "Wrap off")</button>
+        <button type="button" class="btn btn-link btn-sm p-0 text-decoration-none" @onclick="ToggleMinimap"
+                title="Toggle minimap">@(_minimap ? "Minimap on" : "Minimap off")</button>
+        <button type="button" class="btn btn-link btn-sm p-0 text-decoration-none" @onclick="ToggleTheme"
+                title="Toggle theme">@(_dark ? "Dark" : "Light")</button>
+    </div>
+}
+
 <div @ref="_hostRef" class="monaco-editor-host"
      style="height: @Height; border: 1px solid var(--bs-border-color); border-radius: 0.25rem; overflow: hidden;"></div>
 
@@ -11,13 +25,22 @@
     [Parameter] public string Language { get; set; } = "csharp";
     [Parameter] public string Height { get; set; } = "320px";
     [Parameter] public bool ReadOnly { get; set; } = false;
+    [Parameter] public bool ShowToolbar { get; set; } = true;
 
     /// <summary>
     /// Parameter names declared on the form (from the ParameterListEditor),
-    /// surfaced as completions inside Parameters["..."] literals.
+    /// surfaced as completions inside Parameters["..."] literals and used by
+    /// the unknown-key diagnostic.
     /// </summary>
     [Parameter] public IReadOnlyList<string>? DeclaredParameters { get; set; }
 
+    /// <summary>
+    /// Full shapes (name + type + required) for the declared parameters.
+    /// Used by Parameters["name"] hover to show the declared type. If null,
+    /// derived from <see cref="DeclaredParameters"/> with type "Object".
+    /// </summary>
+    [Parameter] public IReadOnlyList<ScriptAnalysis.ParameterShape>? DeclaredParameterShapes { get; set; }
+
     /// <summary>
     /// Shapes (name + parameter list + return type) of other scripts on the
     /// same template. Surfaced inside CallScript("...") for completion,
@@ -25,11 +48,21 @@
     /// </summary>
     [Parameter] public IReadOnlyList<ScriptAnalysis.ScriptShape>? SiblingScripts { get; set; }
 
+    /// <summary>
+    /// Fires whenever Monaco's marker set updates (after the 500 ms diagnostic
+    /// debounce). Hosts can render a <see cref="ProblemsPanel"/> with the same
+    /// data.
+    /// </summary>
+    [Parameter] public EventCallback<IReadOnlyList<ScriptAnalysis.DiagnosticMarker>> MarkersChanged { get; set; }
+
     private ElementReference _hostRef;
     private DotNetObjectReference<MonacoEditor>? _dotNetRef;
     private readonly string _id = Guid.NewGuid().ToString("N");
     private string _lastSentValue = "";
     private bool _initialized;
+    private bool _wrap;
+    private bool _minimap;
+    private bool _dark;
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
@@ -71,6 +104,17 @@
         return ValueChanged.InvokeAsync(_lastSentValue);
     }
 
+    [JSInvokable]
+    public Task OnMarkersChanged(ScriptAnalysis.DiagnosticMarker[] markers) =>
+        MarkersChanged.InvokeAsync(markers ?? Array.Empty<ScriptAnalysis.DiagnosticMarker>());
+
+    /// <summary>Programmatic scroll-to-line (called by the problems panel).</summary>
+    public async Task RevealLineAsync(int line, int column = 1)
+    {
+        if (!_initialized) return;
+        try { await JS.InvokeVoidAsync("MonacoBlazor.revealLine", _id, line, column); } catch { }
+    }
+
     /// <summary>
     /// Called from JS at completion-request time so the form's latest state is
     /// passed through, not whatever was captured when the editor was created.
@@ -78,7 +122,34 @@
     [JSInvokable]
     public ScadaContext GetContext() => new(
         DeclaredParameters?.ToArray() ?? Array.Empty<string>(),
-        SiblingScripts?.ToArray() ?? Array.Empty<ScriptAnalysis.ScriptShape>());
+        SiblingScripts?.ToArray() ?? Array.Empty<ScriptAnalysis.ScriptShape>(),
+        DeclaredParameterShapes?.ToArray()
+            ?? DeclaredParameters?.Select(n => new ScriptAnalysis.ParameterShape(n, "Object", true)).ToArray()
+            ?? Array.Empty<ScriptAnalysis.ParameterShape>());
+
+    private async Task FormatAsync()
+    {
+        if (!_initialized) return;
+        try { await JS.InvokeVoidAsync("MonacoBlazor.format", _id); } catch { }
+    }
+
+    private async Task ToggleWrap()
+    {
+        _wrap = !_wrap;
+        try { await JS.InvokeVoidAsync("MonacoBlazor.setEditorOption", _id, "wordWrap", _wrap ? "on" : "off"); } catch { }
+    }
+
+    private async Task ToggleMinimap()
+    {
+        _minimap = !_minimap;
+        try { await JS.InvokeVoidAsync("MonacoBlazor.setEditorOption", _id, "minimap", new { enabled = _minimap }); } catch { }
+    }
+
+    private async Task ToggleTheme()
+    {
+        _dark = !_dark;
+        try { await JS.InvokeVoidAsync("MonacoBlazor.setEditorOption", _id, "theme", _dark ? "vs-dark" : "vs"); } catch { }
+    }
 
     public async ValueTask DisposeAsync()
     {
@@ -89,5 +160,8 @@
         _dotNetRef?.Dispose();
     }
 
-    public record ScadaContext(string[] DeclaredParameters, ScriptAnalysis.ScriptShape[] SiblingScripts);
+    public record ScadaContext(
+        string[] DeclaredParameters,
+        ScriptAnalysis.ScriptShape[] SiblingScripts,
+        ScriptAnalysis.ParameterShape[] DeclaredParameterShapes);
 }