addition: add (u/i)128 primitive types

[HuntedByTheIRS]

int128: adding primitives

What this adds

u128 and i128 as builtin types in the fork, usable everywhere a u64 is: literals,
arithmetic, shifts, comparisons, constants, statements, string conversion, formatting,
maps, methods and generics.

Nothing in the generated C depends on the C compiler having a wide type. Every operation
becomes a call to a checked-in helper (__v_u128_* / __v_i128_*), so the same program
compiles on gcc, clang, tcc and MSVC. Where __SIZEOF_INT128__ is set the helpers use the
native type for speed; everywhere else a value is a {u64 lo; u64 hi;} struct behind the
same typedef, 16-byte aligned. V_INT128_PORTABLE (or -d v3_no_native_int128) forces the
portable representation, which is how the second path is tested.

Branch shape: 19 commits on top of c9b806b294, 32 files, +2831 / -21, 57 test functions.

Type system

• u128 and i128 accepted as builtin type names and added to the type table.
• Rows i128 16 and u128 17 in the numeric promotion ladder, so u128 wins its mix with
  every narrower integer (checker_tail_stmt.v is the live table; the copy in
  checker_tail.v is dead code and was left alone).
• >>> on a 128-bit operand keeps a 128-bit result type.
• Literal range checking compares digit strings, because strconv stops at 64 bits; a
  literal wider than u128 is an error rather than a silently truncated value.
• A mixed-width arithmetic expression is widened to its 128-bit side in a post-check pass.
  Widening inside the parallel checker is unreliable, and this pass is what the readers of
  a recorded type end up consulting.

Code generation

vlib/v/gen/c/int128.v plus two checked-in headers (int128_helpers.h, int128_string.h).

• Arithmetic, bitwise, shifts, comparisons and both divisions lower to helper calls.
• Division and modulo check for a zero divisor on every path, including compound
  assignment, so they panic like the narrower widths instead of dividing by zero.
• Wide literals are split into 32-bit limbs in the compiler and reconstructed with
  __v_u128_make. Their digits never reach the C compiler, which would keep the low 64
  bits without a warning.
• A 128-bit const is rendered through the expression generator. A C cast plus << neither
  compiles portably nor keeps the value on the native path.
• Statements assemble their own C and each needed its own branch: ++ / -- (a plain
  assignment for a bare identifier, since a block that declares a temporary is illegal in a
  C for post clause), range-loop counters, and compound assignment to an array element.

Standard library

• u128: str, str_base(base), hex, hex_full, bin, char_str.
• i128: str, hex, char_str.
• string.u128(), string.i128() for text to value, zero on garbage like string.u64().
• Format specifiers apply to wide values: '${wide:08x}', :b, :o, :c. Widths pad the
  printed text; the rules for what a specifier accepts match u64 exactly, including the
  ones u64 also rejects.
• Maps and arrays of 128-bit values print their values rather than <map value>.
• typeof and a method receiver on a mixed-width expression name the wider operand:
  typeof(x + u64(1)) is u128, and (x + u64(1)).str() keeps all of its digits.
• markused enqueues the new methods so their bodies are emitted when they are referenced.

Docs

doc/docs.md gains a ### 128-bit integers section, plus i128 and u128 in the type
table: the operators, the two representations, the promotion ladder, wide literals, text
parsing, format specifiers and the map example.

Tests

vlib/v/tests/int128/, 10 files and 57 test functions:

file	covers
arithmetic_test.v	12 tests: operators, shifts, comparisons, wrapping, division
literal_test.v	wide literals keep their exact value, out-of-range is an error
mixed_width_test.v	u64 mixed with u128 on both sides
method_test.v	methods and aliases on the new types
struct_test.v	128-bit fields, arrays, generics
str_test.v	decimal text, interpolation
typeof_test.v	typeof and .str() on mixed-width expressions
surface_test.v	text parsing and the hex/bin/char surface
surface_format_test.v	format specifiers and map printing
panic_test.v	division by zero exits non-zero, via a compiled throwaway program

panic_test.v writes a program, compiles it with @VEXE and requires a non-zero exit,
because v test has no way to assert that something must panic.

Verification

./v -nocache -cc gcc test vlib/v/tests/int128/                # 10 / 10
./v -nocache -cc tcc test vlib/v/tests/int128/                # 10 / 10
./v -nocache -cc clang test vlib/v/tests/int128/              # 10 / 10
./v -nocache -cc gcc -d v3_no_native_int128 test vlib/v/tests/int128/   # 10 / 10
./v vlib/v/compiler_errors_test.v                             # 10 failed / 43 passed / 53 total

The last line is the regression floor and it is unchanged from before this work, so compare
those three counts rather than the exit status. The clang leg, the forced-portable leg and a
mingw + wine cross build were run during the work; gcc and tcc were re-run on the final tree.

Limits worth writing down

• json and json2 have no encoder for either type.
• A bare literal beyond int is still an error in a file. The REPL types its own literals,
  because it compiles a program it wrote itself.
• A wide literal inside an array or map literal needs an explicit u128(...); the expected
  element type does not reach the literal.
• vlib/v/slow_tests/repl/repl_test.v fails on pre-existing stale expectations (several
  cases expect the old error output without the REPL's Compiler output from the default V compiler: header). It fails identically with the pre-change vrepl.v, so it is not a
  usable gate for this branch.

Not part of the feature

Two of the 19 commits are unrelated and can be dropped or split into their own PR:

• 4544694a5b, bbaabbc3ca — cmd/tools/vrepl.v and a REPL corpus case: the REPL gives an
  integer literal beyond int the type it needs instead of refusing it or wrapping it.
• 1914701fda — a .gitignore entry for the .v3cc build folder a self-compile leaves
  behind.

Commits

6a9d0e9f31 types, parser: accept u128 and i128 as builtin type names
9e899e42fb types: give a 128-bit operand of >>> a 128-bit result type
9a83959ece cgen: lower u128 and i128 operations to 128-bit helper calls
17b85b85c2 docs: describe the 128-bit integer primitives
92e35c7b0a cgen: stop emitting a compound assignment target twice
47815bcc84 builtin, transform: print 128-bit values as decimal text
211f93a6fa docs: note that 128-bit values print
3744801c88 docs: fix the formatting of the 128-bit example
c31111233d cgen, types: keep the exact value of a 128-bit literal
390eb18d82 markused, tests: keep the str method of a 128-bit value
87af24405f types, cgen, transform: fix five defects found in review
b236fbe20d types, transform: type a mixed-width expression from its 128-bit side
49e9c3b663 cgen, types, transform, builtin: lower the remaining 128-bit statements
27431d85fe types: format the mixed-width type helpers
f7c5ace945 builtin, transform, cgen, markused: format and print 128-bit values
6289de64b6 transform: name the wider operand in typeof and in a mixed-width .str()
4544694a5b vrepl: give an integer literal beyond int the type it needs
bbaabbc3ca vrepl: cover wide literals with a corpus case
1914701fda gitignore: the C build folder a self compile leaves behind

Files

.gitignore
cmd/tools/vrepl.v
doc/docs.md
vlib/builtin/int.v
vlib/builtin/string.v
vlib/v/gen/c/array.v
vlib/v/gen/c/cleanc.v
vlib/v/gen/c/int128.v
vlib/v/gen/c/int128_helpers.h
vlib/v/gen/c/int128_string.h
vlib/v/gen/c/stmt.v
vlib/v/gen/c/str_intp.v
vlib/v/markused/markused.v
vlib/v/parser/parser.v
vlib/v/slow_tests/repl/wide_integer_literals.repl
vlib/v/tests/int128/arithmetic_test.v
vlib/v/tests/int128/literal_test.v
vlib/v/tests/int128/method_test.v
vlib/v/tests/int128/mixed_width_test.v
vlib/v/tests/int128/panic_test.v
vlib/v/tests/int128/str_test.v
vlib/v/tests/int128/struct_test.v
vlib/v/tests/int128/surface_format_test.v
vlib/v/tests/int128/surface_test.v
vlib/v/tests/int128/typeof_test.v
vlib/v/transform/fn.v
vlib/v/transform/transform.v
vlib/v/types/checker.v
vlib/v/types/checker_comptime.v
vlib/v/types/checker_tail_stmt.v
vlib/v/types/type.v
vlib/v/types/universe.v

[HuntedByTheIRS]

@codex review pls yo 🥺

[JalonSolov]

Local AI Findings

High: Mixed i128/u64 expressions truncate valid u64 values to signed i64. In int128.v, signed expressions convert every narrow operand through i64; therefore i128(0) + u64(0xffffffffffffffff) becomes -1, and i128(0) < u64(0xffffffffffffffff) incorrectly evaluates false. Use zero-extension for unsigned operands while widening.

[HuntedByTheIRS]

Local AI Findings

High: Mixed i128/u64 expressions truncate valid u64 values to signed i64. In int128.v, signed expressions convert every narrow operand through i64; therefore i128(0) + u64(0xffffffffffffffff) becomes -1, and i128(0) < u64(0xffffffffffffffff) incorrectly evaluates false. Use zero-extension for unsigned operands while widening.

thanks m8