Follow-up to the discussion in #8348.

Built-in exceptions that carry a payload (a #[repr(C)] struct with extra
fields) are currently constructed either through PyType::call
(via invoke_exception) or through a bespoke per-type builder like
OSErrorBuilder. This adds a generic helper for the internal builders that
know their exact type at compile time, so they can construct directly
(py_new + slot_init) without going through PyType::call:

pub fn new_payload_exception<T>(&self, cls: PyTypeRef, args: FuncArgs) -> PyResult<PyRef<T>>
where
    T: Constructor<Args = FuncArgs> + Initializer,
{
    let payload = T::py_new(&cls, args.clone(), self)?;
    // cls not matching T structurally is a caller bug, not a runtime error
    let exc = payload
        .into_ref_with_type_lazy_dict(self, cls)
        .expect("new_payload_exception: cls is not a matching subtype of T");
    T::slot_init(exc.as_object().to_owned(), args, self)?;
    Ok(exc)
}

new_exception stays as the thin, restricted fast path for payload-free
types, and invoke_exception still handles the runtime-typed / user-subclass
path (raise <expr>, C-API) — a helper parameterized on a compile-time T
can't respect a user subclass's overridden __new__/__init__.

Error handling: only into_ref_with_type_lazy_dict is .expected — it
fails when cls doesn't structurally match T, which is a caller mistake that
user input can't cause. py_new and slot_init propagate with ?, so a
legitimately-rejected argument (e.g. __init__ refusing a bad value) surfaces
as a normal Python exception.

Routes new_stop_iteration and OSErrorBuilder through the helper as the
first two call sites — the simplest and most complex payload exceptions
respectively. Behaves identically to before and simplifies OSErrorBuilder.

Open questions

Opening as a draft mainly to get feedback on a couple of points:

• Owned upcast. Call sites like new_stop_iteration return
  PyBaseExceptionRef, so the helper's PyRef<T> needs an owned upcast. I used
  .upcast(), which goes through a runtime downcast. The zero-cost conversions
  (upcast_ref/to_base) only yield &Py<_>, and into_base downcasts too, so
  I don't see a zero-cost owned conversion here — is the downcast fine to keep?
• Trait bound. Constructor<Args = FuncArgs> + Initializer doesn't actually
  constrain T to an exception type. Not sure whether that's worth tightening.