Check Python object allocation failures in upb bindings (#30614)

## Summary

Handle failed Python object allocations in several upb Python binding paths.

This change addresses cases where `PyType_GenericAlloc()` could return `NULL`
but the result was used immediately without validation. In an allocation
failure scenario, the code could dereference a NULL pointer and terminate the
Python process instead of propagating the allocation failure as a Python
exception.

## Background

`PyType_GenericAlloc()` is a Python C API allocation function. It may return
`NULL` when object allocation fails, for example when the process is under
memory pressure. Callers must check the returned pointer before initializing
the object.

The affected code paths assigned fields to the result immediately after the
allocation call. If allocation failed, these assignments could dereference
`NULL`, causing a native crash and preventing the original `MemoryError` from
being propagated normally.

## Affected paths

### Extension dictionary creation

PyUpb_Message_GetExtensionDict
  -> PyUpb_ExtensionDict_New
  -> PyType_GenericAlloc
  -> ext_dict->msg

If allocation failed, `ext_dict` was `NULL` before `ext_dict->msg` was accessed.

### Map iterator creation

Python map iteration
  -> PyUpb_MapIterator_New
  -> PyType_GenericAlloc
  -> iter->map

The iterator constructor used the allocated object before checking whether
allocation succeeded.

### Message object creation

PyUpb_RepeatedCompositeContainer_AppendNew
  -> PyUpb_Message_Get
  -> PyUpb_Descriptor_GetClass
  -> PyType_GenericAlloc

The message creation path now returns immediately when class lookup or object
allocation fails. An invalid `Py_DECREF(NULL)` in the allocation failure path
was also removed.

## Impact

These issues are most relevant under allocation failure or severe memory
pressure rather than during ordinary input processing. Without the checks, a
failed allocation could result in:

- NULL pointer dereference;
- termination of the Python interpreter;
- loss of the original allocation error;
- failure to propagate `MemoryError` through the normal Python API.

The practical impact is primarily process stability and availability. The
patch does not change the behavior of successful object creation.

## Changes

- Check the result of `PyType_GenericAlloc()` in
  `PyUpb_ExtensionDict_New`.
- Check the result of `PyType_GenericAlloc()` in
  `PyUpb_MapIterator_New`.
- Preserve the normal error return from `PyUpb_Message_Get()` when class lookup
  or object allocation fails.
- Remove the invalid `Py_DECREF(NULL)` from the message allocation failure
  path.

Related allocation checks in other Python binding constructors are already
present in the current upstream code and are not duplicated by this change.

## Significance

These checks make allocation failure paths conform to the Python C API error
handling convention. They ensure that object construction either returns a
valid initialized object or returns `NULL` so that the active Python exception
can be propagated to the caller.

This is a defensive stability improvement for unusual but valid interpreter
states, including memory pressure and allocation-failure testing.

Closes #30614

COPYBARA_INTEGRATE_REVIEW=https://github.com/protocolbuffers/protobuf/pull/30614 from dynapx:python-allocation-error-handling 0112317d1cd4ab5e9f072e807cab6e1648ad3f38
PiperOrigin-RevId: 1003153689