import: spec-blind suite (40 tests); POSIX two-digit years; exact sub-cent text

tests/spec_import.rs, written from the import crate's specs and sources
alone: every statement foots as printed on random books (P&L, balance
sheet with and without members, cash flow, trial balance, members'
equity), format_amount round-trips, bank CSV round-trips in both layouts
with date-order scenarios, IIF transactions sum to zero with every
account declared and ASCII fields, XLSX cells read back through a small
zip/DEFLATE reader, PDF labels with Typst markup render as text and the
bytes are deterministic, chart CSV and templates.

Its two findings, both fixed:
- "1/15/69" parsed as 2069: chrono's %y cuts over at 70, POSIX strptime
  at 69 (69-99 are 1900s). Two-digit years are computed by POSIX now.
- An amount finer than a cent went into an XLSX as rounded text ("1.01"
  for 1.005); it is written as its exact text now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GWVo7x3UHw5kwCUaWxiejX

crates/ledger-import/src/xlsx.rs

@@ -155,7 +155,7 @@ fn number(
         None => sheet.write_string_with_format(
             row,
             col,
-            crate::report::format_amount(d),
+            exact_text(d),
             &fmt.clone().set_align(rust_xlsxwriter::FormatAlign::Right),
         )?,
     };
@@ -395,6 +395,26 @@ fn general_journal(
 }
 
 /// Decimal to f64 at the presentation boundary. Rounded to cents first.
+/// An amount as exact text: thousands grouped, every decimal it has (at
+/// least two), a negative in parentheses. Never rounded.
+fn exact_text(d: Decimal) -> String {
+    let places = d.normalize().scale().max(2) as usize;
+    let fixed = format!("{:.*}", places, d.abs());
+    let (int, frac) = fixed.split_once('.').expect("decimals");
+    let mut grouped = String::new();
+    for (i, c) in int.chars().enumerate() {
+        if i > 0 && (int.len() - i) % 3 == 0 {
+            grouped.push(',');
+        }
+        grouped.push(c);
+    }
+    if d.is_sign_negative() && !d.is_zero() {
+        format!("({grouped}.{frac})")
+    } else {
+        format!("{grouped}.{frac}")
+    }
+}
+
 /// The double a cell holds for `d`, when Excel will show it exactly: whole
 /// cents, at most 15 significant digits. None otherwise.
 fn exact_f64(d: Decimal) -> Option<f64> {