docs: int is platform width, not always 32-bit

Since #28293 (25f5ced) `int` lowers to `i64` on 64-bit targets and to
`i32` on 32-bit ones, but the Primitive types note still said "Unlike C
and Go, `int` is always a 32 bit integer".

The raw inline-assembly example had the same stale assumption: it used
`addl` on two `int` operands, which fails under gcc with "incorrect
register `%rax' used with `l' suffix" (the same problem as #28870). Its
operands are now `i32`, with a sentence on why.

Co-Authored-By: WOZCODE <contact@withwoz.com>

Author: PythonWillRule

doc/docs.md

@@ -631,7 +631,8 @@ voidptr // this one is mostly used for [C interoperability](#v-and-c)
 ```
 
 > [!NOTE]
-> Unlike C and Go, `int` is always a 32 bit integer.
+> `int` is a platform-width signed integer: 64 bits on 64-bit targets and 32 bits on 32-bit
+> targets. Use `i32` or `i64` when you need a fixed width.
 
 There is an exception to the rule that all operators
 in V must have values of the same type on both sides. A small primitive type
@@ -9314,8 +9315,8 @@ double-quoted template string through unchanged and still checks the output, inp
 lists. Operands can use GNU's named form or V's `constraint (expression) as alias` form:
 
 ```v ignore
-mut value := 40
-increment := 2
+mut value := i32(40)
+increment := i32(2)
 asm amd64 raw {
     "addl %[increment], %[value]\n\t"
     ; [value] "+r" (value)
@@ -9325,6 +9326,10 @@ asm amd64 raw {
 assert value == 42
 ```
 
+The operands are `i32` because `addl` is a 32-bit instruction: a plain `int` is 64 bits wide on a
+64-bit target, so the C compiler would substitute a 64-bit register, which the GNU assembler
+rejects for an `l`-suffixed instruction.
+
 Raw templates are the right level for hand-written kernels that need GNU assembler features such
 as local labels or explicit operand modifiers. A label made with `%=` gets a unique numeric suffix
 for each inline-assembly statement, so prefer names such as `.Lloop%=` for loops in reusable