[Jahongir-Qurbonov]

LowLevelIRBuilder.coerce only had a direct path between native ints of
the same signedness. Coercing an unsigned native int (u8, u16, u32,
u64) to a signed one fell through to the generic box/unbox path, so a
Python int was allocated and freed every time. This happens when an
unsigned value is passed to a primitive that takes i64, for example
indexing bytes:

from mypy_extensions import u64

def f(b: bytes, i: u64) -> int:
    return b[i]

Before this change, the IR for f started with
r0 = box(u64, i); r1 = unbox(i64, r0), and u8/u16/u32 indexes
did the same.

Now the coercion is done inline. If the target type is wider, it's a
zero-extending Extend. Otherwise the value is range checked against
the target's maximum and then truncated. Values that don't fit raise the
same ValueError as before: the u64 -> i64 overflow uses a new
CPyInt64_Overflow helper with the existing "int too large to convert
to i64" message. This is an implicit coercion, so it has to keep the
value. It doesn't wrap around like an explicit i64(x) call.

This also adds the reverse direct path, signed → unsigned (e.g. cast(u64, x) with x: i64, cast(u8, x) with x: i32), which also went through box/unbox before. The value is checked to be non-negative, and when the source type is wider than the target, also checked against the target's maximum; then it's zero-extended or truncated. Out-of-range values raise the same ValueError("int too large or small to convert to uN") as unboxing, using the existing CPyUIntN_Overflow helpers.

Indexing bytes, or str in ord(s[i]) and s[i] == "x", with a u64 index >= 2**63 raised ValueError: int too large to convert to i64 (from the coercion to the i64 index the specialized primitives take), while CPython raises IndexError. Such a value is always out of range, so it now branches to the existing IndexError block instead; this replaces the overflow check emitted by the coercion, so there's no extra overhead. Smaller unsigned types always fit in i64 and are unaffected.

I added irbuild tests for bytes indexing with u64 and u8 indexes,
and run tests for u8, u32 and u64 indexes that cover edge values:
in range, just out of range, 2**63 - 1, 2**63 and 2**64 - 1.

The later commits add irbuild tests for cast() from signed to unsigned types and run tests covering boundaries (0, -1, the target's maximum and maximum + 1, the source's minimum and maximum) for several width combinations, and bytes/str index tests now expect IndexError for u64 values >= 2**63.