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/bank_csv.rs

@@ -195,15 +195,21 @@ fn parse_date(s: &str, order: DateOrder) -> Result<NaiveDate, BankCsvError> {
     if let Ok(d) = NaiveDate::parse_from_str(s, "%Y-%m-%d") {
         return Ok(d);
     }
-    let (four, two) = match order {
-        DateOrder::MonthFirst => ("%m/%d/%Y", "%m/%d/%y"),
-        DateOrder::DayFirst => ("%d/%m/%Y", "%d/%m/%y"),
+    let four = match order {
+        DateOrder::MonthFirst => "%m/%d/%Y",
+        DateOrder::DayFirst => "%d/%m/%Y",
     };
-    // A four-digit year first; a two-digit year follows POSIX (69-99 are
-    // 1900s), as chrono's %y does.
-    let year_digits = s.rsplit('/').next().map_or(0, str::len);
-    let format = if year_digits == 2 { two } else { four };
-    NaiveDate::parse_from_str(s, format).map_err(|_| BankCsvError::BadDate(s.to_string()))
+    let bad = || BankCsvError::BadDate(s.to_string());
+    let (rest, year) = s.rsplit_once('/').ok_or_else(bad)?;
+    if year.len() != 2 {
+        return NaiveDate::parse_from_str(s, four).map_err(|_| bad());
+    }
+    // A two-digit year follows POSIX strptime %y: 69-99 are 1900s, 00-68
+    // 2000s. (chrono's %y puts the cutoff at 70; found by the spec-blind
+    // suite, 2026-10-13.)
+    let yy: i32 = year.parse().map_err(|_| bad())?;
+    let full = if yy >= 69 { 1900 + yy } else { 2000 + yy };
+    NaiveDate::parse_from_str(&format!("{rest}/{full}"), four).map_err(|_| bad())
 }
 
 fn parse_amount(s: &str) -> Result<Decimal, BankCsvError> {