Optimize try_reserve by implementing TODO (remove redundant overflow check)

[AriajSarkar]

Following up on #787, I noticed the TODO comment suggests removing
the checked_add since it's redundant given MAX_SIZE bounds.

Since I'm familiar with this code area,
I wanted to implement this small optimization. Let me know if now is
a good time or if you'd prefer to defer this.

Link(Fix): https://github.com/AriajSarkar/http/blob/c567928c430262295b3a587ecc3aa00f657f4704/src/header/map.rs#L746

Problem

Current implementation (line 746-752):

// TODO: This can't overflow if done properly... since the max # of
// elements is u16::MAX.
let cap = self
    .entries
    .len()
    .checked_add(additional)
    .ok_or_else(MaxSizeReached::new)?;

The checked_add is redundant because:

1. self.entries.len() <= MAX_SIZE (data structure invariant)
2. MAX_SIZE = 32,768 (fits in u16)
3. Even with additional + self.entries.len(), we validate against MAX_SIZE later via to_raw_capacity

Solution

Replace checked_add with an early bounds check:

// Early bounds check: Since self.entries.len() <= MAX_SIZE (invariant),
// and MAX_SIZE fits in u16, we can avoid checked_add by validating
// that additional won't cause the total to exceed MAX_SIZE.
let current_len = self.entries.len();
if additional > MAX_SIZE.saturating_sub(current_len) {
    return Err(MaxSizeReached::new());
}

// Safe: We've verified that current_len + additional <= MAX_SIZE,
// which is well within usize range, so no overflow is possible.
let cap = current_len + additional;

Benefits

1. Performance: Eliminates one checked_add operation per try_reserve call
2. Clarity: Makes the MAX_SIZE constraint explicit upfront
3. Early failure: Rejects invalid requests before unnecessary computation