perf(decoder): @inline(__always) on decodeFixedWidthInteger helpers

A direct BEFORE/AFTER benchmark on Apple M2 Pro caught the generic
helpers added in c4531f3 introducing a +5% mean regression on numeric-
heavy decode paths (e.g. `Decode 100K rows (numeric fields)` +6.4%,
`Decode 100K rows (simple)` +5.2%). The compiler wasn't fully
specialising the `<T: FixedWidthInteger>` generic across all nine call
sites without the hint.

Adding `@inline(__always)` to both helpers collapses the regression to
within run-to-run noise (≤+2% on remaining cases, several scenarios
actually faster than the pre-refactor baseline):

  Decode 100K rows (simple)         153.05 → 154.51 ms  +0.95%
  Decode 100K rows (numeric)        157.27 → 159.82 ms  +1.62%
  Decode 100K transactions          501.64 → 498.26 ms  -0.67%
  Decode 100K log entries           490.61 → 489.19 ms  -0.29%
  Encode 100K rows                  129.09 → 125.28 ms  -2.95%
  Encode 10K rows (quoted)           11.92 →  11.71 ms  -1.76%
  Encode 100K rows to String        127.37 → 124.69 ms  -2.10%
  Mixed: Decode+Transform+Encode     29.15 →  28.73 ms  -1.43%

305/305 tests pass.

Author: g-cqd

Sources/CSVCoder/Decoder/CSVRowDecoder.swift

@@ -486,6 +486,11 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol
     /// the field as `Int64`, then narrows via `T(exactly:)`. The type name
     /// in the diagnostic comes from `T` itself so adding a new integer
     /// width never drifts from the error message.
+    ///
+    /// `@inline(__always)` is required: without it the bench measured a
+    /// +5% regression on numeric-heavy decode paths because the generic
+    /// helper wasn't fully specialised through all nine call sites.
+    @inline(__always)
     private func decodeFixedWidthInteger<T: FixedWidthInteger>(
         _ type: T.Type,
         forKey key: Key

Sources/CSVCoder/Decoder/CSVSingleValueDecoder.swift

@@ -160,6 +160,11 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
     /// the trimmed field as `Int64`, then narrows via `T(exactly:)`. The
     /// type name in the diagnostic comes from `T` itself so adding a new
     /// integer width never drifts from the error message.
+    ///
+    /// `@inline(__always)` is required: without it the bench measured a
+    /// +5% regression on numeric-heavy decode paths because the generic
+    /// helper wasn't fully specialised through all nine call sites.
+    @inline(__always)
     private func decodeFixedWidthInteger<T: FixedWidthInteger>(_ type: T.Type) throws -> T {
         guard let raw = CSVValueParser.parseInt64(trimmedValue, strategy: configuration.numberDecodingStrategy),
             let result = T(exactly: raw)