fix(driver-focas-cli): resolve Low code-review findings (Driver.FOCAS.Cli-001,002,003,004; -005 deferred)

- Driver.FOCAS.Cli-001: WriteCommand.ParseValue now wraps numeric
  FormatException / OverflowException as CliFx CommandException with
  the offending value.
- Driver.FOCAS.Cli-002: SubscribeCommand's OnDataChange handler and the
  banner both take a writeLock so notification-callback and main-thread
  writes can't interleave; handler exceptions are warn-and-swallow.
- Driver.FOCAS.Cli-003: FocasCommandBase.ValidateOptions rejects
  --cnc-port outside 1..65535, non-positive --timeout-ms, and
  non-positive --interval-ms; ExecuteAsync calls it first.
- Driver.FOCAS.Cli-004: 'await using var driver' is the sole driver
  disposal path; dropped the redundant explicit await ShutdownAsync.
- Driver.FOCAS.Cli-005 (Deferred): the fix lives in
  Driver.Cli.Common.SnapshotFormatter — explicitly naming the
  status-code shortlist there benefits every driver CLI. Left as a
  Driver.Cli.Common follow-up.
- Registered the new tests/Drivers/Cli/ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Cli.Tests
  project in ZB.MOM.WW.OtOpcUa.slnx.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/Drivers/Cli/ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Cli/Commands/WriteCommand.cs

@@ -29,6 +29,10 @@ public sealed class WriteCommand : FocasCommandBase
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
+        // Driver.FOCAS.Cli-003: validate numeric option ranges before any driver work so
+        // a zero/negative port/timeout surfaces as a clean CommandException rather than an
+        // opaque downstream exception.
+        ValidateOptions();
         var ct = console.RegisterCancellationHandler();
 
         var tagName = ReadCommand.SynthesiseTagName(Address, DataType);
@@ -42,30 +46,49 @@ public sealed class WriteCommand : FocasCommandBase
 
         var parsed = ParseValue(Value, DataType);
 
+        // Driver.FOCAS.Cli-004: `await using` is the sole disposal mechanism — FocasDriver.DisposeAsync
+        // already invokes ShutdownAsync, so a redundant explicit ShutdownAsync(CancellationToken.None)
+        // in a finally block ran shutdown twice. The await-using on the next line is enough.
         await using var driver = new FocasDriver(options, DriverInstanceId);
-        try
-        {
-            await driver.InitializeAsync("{}", ct);
-            var results = await driver.WriteAsync([new WriteRequest(tagName, parsed)], ct);
-            await console.Output.WriteLineAsync(SnapshotFormatter.FormatWrite(Address, results[0]));
-        }
-        finally
-        {
-            await driver.ShutdownAsync(CancellationToken.None);
-        }
+        await driver.InitializeAsync("{}", ct);
+        var results = await driver.WriteAsync([new WriteRequest(tagName, parsed)], ct);
+        await console.Output.WriteLineAsync(SnapshotFormatter.FormatWrite(Address, results[0]));
     }
 
-    internal static object ParseValue(string raw, FocasDataType type) => type switch
+    /// <summary>Parse <c>--value</c> per <see cref="FocasDataType"/>, invariant culture throughout.</summary>
+    /// <remarks>
+    ///     Driver.FOCAS.Cli-001: numeric parses are wrapped so that malformed input
+    ///     (<see cref="FormatException"/> / <see cref="OverflowException"/>) surfaces
+    ///     as a clean <see cref="CliFx.Exceptions.CommandException"/> rather than a raw
+    ///     .NET stack trace — matching the friendly message the Bit path already produces.
+    /// </remarks>
+    internal static object ParseValue(string raw, FocasDataType type)
     {
-        FocasDataType.Bit => ParseBool(raw),
-        FocasDataType.Byte => sbyte.Parse(raw, CultureInfo.InvariantCulture),
-        FocasDataType.Int16 => short.Parse(raw, CultureInfo.InvariantCulture),
-        FocasDataType.Int32 => int.Parse(raw, CultureInfo.InvariantCulture),
-        FocasDataType.Float32 => float.Parse(raw, CultureInfo.InvariantCulture),
-        FocasDataType.Float64 => double.Parse(raw, CultureInfo.InvariantCulture),
-        FocasDataType.String => raw,
-        _ => throw new CliFx.Exceptions.CommandException($"Unsupported DataType '{type}' for write."),
-    };
+        if (type == FocasDataType.Bit) return ParseBool(raw);
+        if (type == FocasDataType.String) return raw;
+        try
+        {
+            return type switch
+            {
+                FocasDataType.Byte    => (object)sbyte.Parse(raw, CultureInfo.InvariantCulture),
+                FocasDataType.Int16   => (object)short.Parse(raw, CultureInfo.InvariantCulture),
+                FocasDataType.Int32   => (object)int.Parse(raw, CultureInfo.InvariantCulture),
+                FocasDataType.Float32 => (object)float.Parse(raw, CultureInfo.InvariantCulture),
+                FocasDataType.Float64 => (object)double.Parse(raw, CultureInfo.InvariantCulture),
+                _ => throw new CliFx.Exceptions.CommandException($"Unsupported DataType '{type}' for write."),
+            };
+        }
+        catch (FormatException ex)
+        {
+            throw new CliFx.Exceptions.CommandException(
+                $"Value '{raw}' is not a valid {type}: {ex.Message}");
+        }
+        catch (OverflowException ex)
+        {
+            throw new CliFx.Exceptions.CommandException(
+                $"Value '{raw}' is out of range for {type}: {ex.Message}");
+        }
+    }
 
     private static bool ParseBool(string raw) => raw.Trim().ToLowerInvariant() switch
     {