Task #137 — Modbus per-tag suffix grammar (type / bit / byte-order / array)

Adds the full Wonderware/Kepware/Ignition-style address suffix grammar so
users paste tag spreadsheets without per-tag manual translation:

  <region><offset>[.<bit>][:<type>[<len>]][:<order>][:<count>]

Examples that now parse end-to-end:
  40001                          HoldingRegisters[0], Int16
  400001                         same, 6-digit form
  40001.5                        bit 5 of HR[0]
  40001:F                        Float32 (HR[0..1])
  40001:F:CDAB                   word-swapped Float32
  40001:STR20                    20-char ASCII string
  HR1:DI                         Int32 via mnemonic region
  C100                           Coils[99] (mnemonic)
  40001:F:5                      Float32[5] array (3-field shorthand)
  40001:I:CDAB:10                Int16[10] word-swapped (4-field strict)

Driver-side plumbing:
- ModbusAddressParser + ParsedModbusAddress in the shared Addressing
  assembly. 91 parser tests (every grammar variant + malformed shapes).
- ModbusDataType / ModbusByteOrder moved to shared (with the same namespace
  so callers compile unchanged). ModbusByteOrder gains ByteSwap (BADC) and
  FullReverse (DCBA) alongside the existing BigEndian (ABCD) and WordSwap
  (CDAB).
- NormalizeWordOrder extended to honor all four orders for both 4-byte and
  8-byte values. Old WordSwap behavior preserved bit-for-bit.
- ModbusTagDefinition gains optional ArrayCount.
- ReadOneAsync / WriteOneAsync handle array fan-out: one FC03/04 read covers
  N consecutive register-typed elements, decoded into a typed array (short[],
  float[], etc.). Coil arrays use FC01 reads + FC15 writes (FakeTransport
  in tests gains FC15 support to match).
- DriverAttributeInfo IsArray / ArrayDim flow from ArrayCount so the OPC UA
  address space surfaces ValueRank=1 + ArrayDimensions to clients.
- ModbusDriverFactoryExtensions gains AddressString DTO field. When
  present, the parser drives Region/Address/DataType/ByteOrder/Bit/
  StringLength/ArrayCount; structured fields (Writable, WriteIdempotent,
  StringByteOrder) still come from the DTO. Existing structured tag rows
  keep working unchanged.

Tests: 91 parser unit tests (Driver.Modbus.Addressing.Tests, all green) +
204 driver tests including new ModbusByteOrderTests (BADC/DCBA roundtrips
across Int32/Float32/Float64) and ModbusArrayTests (Int16[5], Float32[3]
CDAB, Coil[10], length-mismatch error, IsArray/ArrayDim discovery).
Solution-wide build clean.

Caveat: grammar names (type codes, byte-order mnemonics, the :count
shorthand) were synthesized from training-era vendor docs. Verify against
current Kepware Modbus Ethernet Driver Help and Ignition Modbus Addressing
manuals before freezing for production deployments — naming may need a
back-compat layer if vendor wording has shifted.

src/ZB.MOM.WW.OtOpcUa.Driver.Modbus/ModbusDriverFactoryExtensions.cs

@@ -57,10 +57,38 @@ public static class ModbusDriverFactoryExtensions
         return new ModbusDriver(options, driverInstanceId);
     }
 
-    private static ModbusTagDefinition BuildTag(ModbusTagDto t, string driverInstanceId) =>
-        new(
-            Name: t.Name ?? throw new InvalidOperationException(
-                $"Modbus config for '{driverInstanceId}' has a tag missing Name"),
+    private static ModbusTagDefinition BuildTag(ModbusTagDto t, string driverInstanceId)
+    {
+        var name = t.Name ?? throw new InvalidOperationException(
+            $"Modbus config for '{driverInstanceId}' has a tag missing Name");
+
+        // AddressString takes precedence over the structured fields (Region/Address/DataType/
+        // ByteOrder/BitIndex/StringLength/ArrayCount). Tags can mix forms freely — newer pasted
+        // rows use the grammar string, legacy rows keep the structured form. Fields not derivable
+        // from the grammar (Writable, WriteIdempotent, StringByteOrder) always come from the DTO.
+        if (!string.IsNullOrWhiteSpace(t.AddressString))
+        {
+            if (!ModbusAddressParser.TryParse(t.AddressString, out var parsed, out var parseError))
+                throw new InvalidOperationException(
+                    $"Modbus tag '{name}' in '{driverInstanceId}' has invalid AddressString '{t.AddressString}': {parseError}");
+            return new ModbusTagDefinition(
+                Name: name,
+                Region: parsed!.Region,
+                Address: parsed.Offset,
+                DataType: parsed.DataType,
+                Writable: t.Writable ?? true,
+                ByteOrder: parsed.ByteOrder,
+                BitIndex: parsed.Bit ?? 0,
+                StringLength: parsed.StringLength,
+                StringByteOrder: t.StringByteOrder is null
+                    ? ModbusStringByteOrder.HighByteFirst
+                    : ParseEnum<ModbusStringByteOrder>(t.StringByteOrder, name, driverInstanceId, "StringByteOrder"),
+                WriteIdempotent: t.WriteIdempotent ?? false,
+                ArrayCount: parsed.ArrayCount);
+        }
+
+        return new ModbusTagDefinition(
+            Name: name,
             Region: ParseEnum<ModbusRegion>(t.Region, t.Name, driverInstanceId, "Region"),
             Address: t.Address ?? throw new InvalidOperationException(
                 $"Modbus tag '{t.Name}' in '{driverInstanceId}' missing Address"),
@@ -74,7 +102,9 @@ public static class ModbusDriverFactoryExtensions
             StringByteOrder: t.StringByteOrder is null
                 ? ModbusStringByteOrder.HighByteFirst
                 : ParseEnum<ModbusStringByteOrder>(t.StringByteOrder, t.Name, driverInstanceId, "StringByteOrder"),
-            WriteIdempotent: t.WriteIdempotent ?? false);
+            WriteIdempotent: t.WriteIdempotent ?? false,
+            ArrayCount: t.ArrayCount);
+    }
 
     private static T ParseEnum<T>(string? raw, string? tagName, string driverInstanceId, string field) where T : struct, Enum
     {
@@ -111,6 +141,15 @@ public static class ModbusDriverFactoryExtensions
     internal sealed class ModbusTagDto
     {
         public string? Name { get; init; }
+
+        /// <summary>
+        ///     Address grammar string per <c>ModbusAddressParser</c> — when present, takes
+        ///     precedence over the structured Region/Address/DataType/ByteOrder/BitIndex/
+        ///     StringLength/ArrayCount fields. Examples: <c>"40001"</c>, <c>"40001:F"</c>,
+        ///     <c>"40001:F:CDAB:5"</c>, <c>"HR1:DI"</c>, <c>"C100"</c>.
+        /// </summary>
+        public string? AddressString { get; init; }
+
         public string? Region { get; init; }
         public ushort? Address { get; init; }
         public string? DataType { get; init; }
@@ -120,6 +159,7 @@ public static class ModbusDriverFactoryExtensions
         public ushort? StringLength { get; init; }
         public string? StringByteOrder { get; init; }
         public bool? WriteIdempotent { get; init; }
+        public int? ArrayCount { get; init; }
     }
 
     internal sealed class ModbusProbeDto