Summary

Fixes #19314.

The sequence-repeat operator (seq * n) computed the result size as
len(seq) * n using unchecked size_t arithmetic, allocated a buffer of that
(wrapped) size, and then wrote the full len(seq) * n elements via
mp_seq_multiply(). When the multiplication overflowed size_t the buffer was
under-allocated, causing a heap buffer overflow reachable from pure Python
for str, bytes, list and tuple.

Example (64-bit): (b"A" * 65536) * (2**48) wraps len*n to 0, allocates a
tiny buffer, then copies far past it → crash / memory corruption. On 32-bit
targets the threshold is only 2**32, so an ordinary repeat count is enough
(e.g. (b"x" * 64) * 67108864).

Fix

Check for the overflow before allocating and raise OverflowError (matching
CPython, which raises OverflowError/MemoryError here), instead of corrupting
the heap. The same guard is added to the three callers of mp_seq_multiply():

• py/objstr.c (str / bytes / bytearray)
• py/objlist.c
• py/objtuple.c

Testing

• New regression test tests/basics/sequence_repeat_overflow.py (portable across
  32/64-bit; output matches CPython).
• tests/run-tests.py basics → 545/545 passed (16926 testcases), no regressions.
• Normal repeats (b"ab"*3, [1,2]*3, (1,2)*3, b"A"*1000000) still work.
• Verified the original crashing PoCs now raise OverflowError on the standard
  unix build, and that an ASAN build reports a heap-buffer-overflow in
  mp_seq_multiply before the fix.