Per-field chrono format wrappers: glz::date_format and glz::epoch_count

[stephenberry]

Addresses #2640. Decouples the format of a chrono field from its type, so a single field can opt into a custom representation while others keep the type-driven default. (std::chrono::utc_time support from #2640 is tracked separately in #2657.)

What

Two per-field wrappers, applied inside glz::object(...) in a glz::meta<T> specialization:

• glz::date_format(&T::member, "pattern") — serializes a system_clock time point (or a year_month_day) with a locale-independent strftime-subset pattern instead of ISO 8601.
• glz::epoch_count<Duration>(&T::member) — serializes a system_clock time point as a numeric Unix timestamp in Duration units (the per-field counterpart to the glz::epoch_time storage wrapper).

struct Event {
   std::chrono::system_clock::time_point start{};
   std::chrono::sys_time<std::chrono::milliseconds> logged{};
};
template <> struct glz::meta<Event> {
   using T = Event;
   static constexpr auto value = glz::object(
      "start",  glz::date_format(&T::start, "%Y-%m-%d %H:%M:%S"),          // "2026-06-18 12:34:56"
      "logged", glz::epoch_count<std::chrono::milliseconds>(&T::logged));  // 1781786096789
};

The member pointer is a value argument (and for date_format so is the pattern), not a non-type template parameter — see Implementation notes for why.

Supported tokens (compile-time validated): %Y %m %d %H %M %S %F %T %%. Unsupported tokens, a missing calendar date, or time tokens on a year_month_day field are hard compile errors.

Scope

• JSON / text backends only. These are textual wrappers that route through the JSON serializer, so NDJSON and stencil output work too. A field using them under a native-encoding backend (BEVE, CBOR, MsgPack, BSON, TOML) is a compile error (undefined glz::to<Format, …>), not a silent miscoding.
• %S writes integer seconds; sub-second precision is truncated on write (a %S pattern has nowhere to put a fraction). Use the default ISO 8601 representation for sub-second fidelity.
• UTC wall-clock, no timezone token.

Guarantees

• The year is constrained to [0000, 9999] on both read and write, matching the ISO 8601 path.
• date_format rejects an invalid/default year_month_day on write (constraint_violated), so the writer never emits a string its own reader would reject and an out-of-range month/day cannot slip past write_digits<2>.
• epoch_count validates both its member type and its Duration unit at compile time, so misuse produces a clear diagnostic rather than a deep template cascade.

Implementation notes

• Value-carried, not NTTP. The member pointer (and date_format's pattern) are passed as values, so the view type is keyed on the member type alone and the format lives as a runtime std::string_view. Fields that differ only in their format string no longer each instantiate a fresh date_format_t / to / from / closure — on a synthetic struct of N same-typed members with distinct formats this removes ~40% of the wrapper's template instantiations and makes the per-distinct-format compile cost flat. The pattern stays a compile-time literal: a consteval guard in the date_format(...) factory rejects unsupported tokens, a missing date, or time tokens on a year_month_day. (glz::float_format keeps the NTTP form because it relies on std::format's compile-time format checking; date_format's strftime walk is already runtime, so it has no such dependency.)
• The strftime subset is a small, locale-independent hand-roll in core/chrono.hpp that reuses the existing parse_digits / write_digits primitives, so the [0000, 9999] year and component-range guarantees match the ISO 8601 path.
• The date_format reader anchors its time-point reconstruction at seconds precision (sys_seconds) before folding in the time-of-day. MSVC's std::chrono::hours/minutes use a 32-bit representation, so the natural sys_days + hours + minutes idiom overflows the intermediate minutes count for far-future years; the seconds anchor keeps the arithmetic in 64 bits and the reconstruction exact across libstdc++, libc++, and MSVC.
• float_format's compile-time format-string helper was factored out of json/float_format.hpp into core/format_str.hpp (no behavioral change).

Follow-ups (tracked separately)

• Support std::chrono::utc_time / utc_clock #2657 — std::chrono::utc_time / utc_clock support (the remaining part of Chrono Improvements #2640).
• Per-field wrappers don't peek through std::optional (and other transparent wrappers) #2655 — per-field wrappers should peek through std::optional.
• Field wrappers emit an incorrect JSON Schema (catch-all union instead of the field's wire type) #2656 — field wrappers emit an incorrect JSON Schema (catch-all union instead of the wire type).