update versioned types

[pgherveou]

Versioned message envelopes

Versioned request/response/error types in truapi::versioned are SCALE enums
whose variants (V1, V2, …) are successive versions of one logical message,
newest last. They are generated by the versioned_type! function-like proc
macro:

versioned_type! {
    pub enum HostFooRequest  { V1 => v01::HostFooRequest }
    pub enum HostFooResponse { V1 }
}

The macro assigns positional SCALE codec indices, enforces contiguous
V1..=Vn, and implements Versioned (the Latest payload type, the LATEST
version number, and version()). Single-version envelopes additionally get
trivial IntoLatest/FromLatest; multi-version envelopes implement those by
hand, since the conversion between versions is bespoke. Adding a version is one
line on the envelope plus the hand-written conversion for the direction that
changed.

Conversion contract

Three traits express how a server moves between wire versions and its internal
"latest" representation. Both directions are total by construction, so the
mapping for an old client is decided at design time rather than failing at
runtime:

pub trait Versioned: Sized {
    type Latest;
    const LATEST: u8;
    fn version(&self) -> u8;
}

/// Request path: upgrade a received envelope to its latest payload.
pub trait IntoLatest: Versioned {
    fn into_latest(self) -> Self::Latest;
}

/// Response/error path: downgrade a latest payload to the variant `target` understands.
pub trait FromLatest: Versioned {
    fn from_latest(latest: Self::Latest, target: u8) -> Self;
}

Intended server usage

The traits are shaped so the whole version dance collapses into one generic
dispatch step. Handlers are written once against *::Latest and never observe
older versions. (The adapter itself is not part of this PR; it lands with the
server work.)

pub async fn dispatch<Req, Resp, Err, F, Fut>(req: Req, handle: F) -> Result<Resp, Err>
where
    Req: IntoLatest,
    Resp: FromLatest,
    Err: FromLatest,
    F: FnOnce(Req::Latest) -> Fut,
    Fut: Future<Output = Result<Resp::Latest, Err::Latest>>,
{
    let target = req.version();                  // version the caller spoke
    match handle(req.into_latest()).await {      // upgrade, then handle in latest terms
        Ok(r)  => Ok(Resp::from_latest(r, target)),   // downgrade response to caller's version
        Err(e) => Err(Err::from_latest(e, target)),   // errors downgrade the same way
    }
}

Codegen

Codegen treats only truapi::api::* traits as protocol surface and skips the
versioned helper traits, so the generated TypeScript client and wire tables
are byte-identical. The emitted types.ts carries no standalone Version
type, since the protocol exposes no such type.

[filvecchiato]

Clean design. Total conversions by construction (IntoLatest/FromLatest are infallible) is the right property — version mismatches are decided at design time, not runtime.

The proc macro is well-structured: contiguity validation, proper error spans, single-variant auto-impl vs multi-variant manual. Test coverage looks good.

Will conflict with #145 on versioned/mod.rs (both remove the old Version/IntoVersion), but resolution is straightforward.

[filvecchiato]

Overall looks good