requisite 0.1.0

Data-handling requirements encoded in Rust types.
Documentation
# Freshness

The `fresh` module checks TTLs at reads and binds operation-scoped values to a
closure.

## Attach a TTL

```rust
use requisite::prelude::*;
use std::time::Duration;

let quote = Fresh::fetch(499_u64, Duration::from_secs(30));
```

`get` borrows the value while its age is within the TTL:

```rust
match quote.get() {
    Ok(cents) => println!("current quote: {cents}"),
    Err(stale) => {
        println!(
            "quote age {:?} exceeded {:?}",
            stale.age, stale.ttl
        );
    }
}
```

`remaining` reports the remaining TTL and saturates at zero:

```rust
println!("remaining: {:?}", quote.remaining());
```

## Move ownership after the check

Use `into_inner` when the next operation needs ownership:

```rust
match quote.into_inner() {
    Ok(cents) => charge(cents),
    Err(expired) => {
        persist_for_audit(expired.value);
        schedule_refresh(expired.stale);
    }
}
```

The error is `StaleValue<T>`, which preserves both the value and the `Stale`
timing information.

## Test stale behavior without sleeping

`fetched_at` accepts a monotonic `Instant` and rejects future timestamps:

```rust
use requisite::prelude::*;
use std::time::{Duration, Instant};

let fetched = Instant::now() - Duration::from_secs(60);
let quote = Fresh::fetched_at(499_u64, fetched, Duration::from_secs(30))?;

assert!(quote.get().is_err());
```

This keeps tests deterministic and avoids timing margins. A future timestamp
returns `InvalidFetchTime` with the amount by which it was ahead.

## Bind a value to one operation

Use `with_live` when APIs should receive a value during one closure:

```rust
use requisite::prelude::*;

let total = with_live(499_u64, |live| {
    let subtotal = *live.get();
    subtotal + 25
});
```

`Live<'id, T>` carries a private invariant lifetime brand. The closure can
return owned results derived from the value, while the branded wrapper remains
inside the invocation.

This pattern is useful when deferred work must receive a computed result rather
than the operation-scoped handle itself.