Add _lite variants that skip backtrace capture

[FuuuOverclocking]

Motivation

Backtrace::capture() incurs a fixed ~4 us overhead per anyhow::Error construction when RUST_LIB_BACKTRACE=1. For most applications this is acceptable, but on hot paths where errors are constructed at high frequency, it becomes a bottleneck. Today the only escape hatch is globally disabling backtraces via environment variable, which sacrifices debuggability everywhere.

Solution

Introduce _lite variants that unconditionally skip backtrace capture:

Standard API	Lite variant
Error::new(e)	Error::new_lite(e)
Error::msg(m)	Error::msg_lite(m)
anyhow!(...)	anyhow_lite!(...)
.context(c)	.context_lite(c)
.with_context(f)	.with_context_lite(f)

Plus Error::backtraced() to retroactively capture a backtrace at a cold boundary, upgrading a lite error without losing the trace entirely.

All variants retain identical error-chaining and downcast semantics.

Benchmark Results (Intel Xeon 6982P-C, pinned core)

Benchmark	BT=0	BT=1 (DWARF)	BT=1 (frame ptr)
thiserror construct	0 ns	0 ns	0 ns
anyhow_lite!()	15 ns	15 ns	15 ns
anyhow!()	16 ns	4,209 ns	4,147 ns
.context_lite()	15 ns	15 ns	16 ns
.context()	17 ns	4,242 ns	4,177 ns

Stack depth scaling (BT=1 DWARF):

Depth	anyhow!()	anyhow_lite!()
8	4,223 ns	16 ns
32	4,228 ns	16 ns
128	4,224 ns	16 ns

The lite variants are ~260x faster, constant at ~15 ns regardless of backtrace settings or stack depth.

Usage

// Hot path: no backtrace overhead
fn hot_loop(items: &[Item]) -> anyhow::Result<()> {
    for item in items {
        parse(item).context_lite("parse failed")?;
    }
    Ok(())
}

// Cold boundary: upgrade with backtrace if needed
pub fn api_entry(items: &[Item]) -> anyhow::Result<()> {
    hot_loop(items).map_err(|e| e.backtraced())
}

FAQ: Why not use thiserror on the hot path from the start?

1. Write correct code first, optimize later. anyhow minimizes boilerplate during early development; optimization should be driven by profiling, not premature decisions.
2. Large codebases make refactoring hard. Converting a deep call chain from anyhow::Result to a custom enum touches every signature and ? site. The _lite suffix is a one-token change at the call site with the same performance benefit.

Design Notes

• All _lite methods pass None for the backtrace parameter to existing internal constructors — no new unsafe code, no architectural changes.
• backtraced() is idempotent: if a backtrace already exists, it's a no-op.
• #[cfg(feature = "std")] gates all backtrace-related additions; no-std builds are unaffected.

[dtolnay]

Thanks for the PR. I would prefer not to support this in this crate and instead encourage anything that would consider using these APIs to switch to a different error type.