[Jahongir-Qurbonov]

Unary minus on an integer literal is constant folded in LowLevelIRBuilder.unary_minus, but the folded value wasn't wrapped around for unsigned native int types (there was a # TODO: Overflow? Unsigned? comment). So -u64(1) became the u64 constant -1 instead of 2**64 - 1:

from mypy_extensions import u64, u8

def f() -> int:
    return -u64(1)  # -1, expected 18446744073709551615

def g() -> int:
    return -u8(1)  # -1, expected 255

def h(x: u64) -> bool:
    return x == -u64(1)  # C compile error: -Werror=sign-compare

str(-u64(1)) also gave "-1", and comparisons or other operations with a negated unsigned literal could produce C code that fails to compile with -Werror=sign-compare. u64, u32, u16 and u8 were all affected.

Now the folded value is taken modulo 2**bits for unsigned types, which matches what negating a non-literal unsigned value does at runtime (and the docs say unsigned operations wrap around on overflow). Large u64 values are already emitted with a ULL suffix. Signed overflow (e.g. -i64(-2**63)) is left alone, since it's undefined behavior per the docs.

I checked related cases like 0 - u64(1) and ~u64(0); they don't go through this folding and already worked, so I only added run tests for them.

Added a test_negate_literal run test to run-u8/u16/u32/u64.test, and irbuild tests for u8 and u64 that show the folded constants.

Negating a Final unsigned native int constant was also rejected, e.g. -X with X: Final[u64] = 1 gave Value -1 is out of range for "u64" (likewise X - 2, ~X, X + 1 for X: Final[u8] = 255, and references to Z: Final[u64] = -X), and "%d" % (-X,) silently produced "-1". Constant folding and Final value loading now wrap int results around for unsigned native int types, at each folded operation, so the results match runtime semantics (e.g. (X - 2) // 2 is 2**63 - 1). Signed native int overflow is undefined behavior, so overflowing signed constant expressions are still reported as errors.

Converting such a constant to int (e.g. int(-u32(1))) generated an unreachable fast path that truncated the constant, which C compilers reject on 32-bit platforms, so large native int constants are now loaded directly as int literals in that case.