Fix wasm64 bindings: Add RetArea infrastructure for 32-bit ABI compatibility

This implements a complete fix for the wasm64 pointer size mismatch issue
identified in PR bytecodealliance#367. On wasm64, Go uses 64-bit pointers but the Component
Model ABI uses 32-bit values exclusively. When functions return pointer-
containing types (strings, lists, options, results), the mismatch causes
data corruption and "unknown handle index 0" errors.

- area.go: Add RetArea1-16 types with uint32 fields for receiving 32-bit
  ABI return values with proper HostLayout alignment
- lift.go: Implement lift/lower functions for converting between 32-bit
  ABI values and Go types:
  - LiftString32, LiftList32: Convert i32 pointers to native pointers
  - LiftOptionString32, LiftOptionList32: Lift option<T> from ABI
  - LiftListWithConverter32: Deep conversion for nested pointer types
  - LiftTupleWithPointers32: Convert tuples with 32-bit pointer fields
  - Result lifting helpers for proper discriminant/payload handling
- wasm64.go: Add IsWasm64 constant for platform detection
- lift_test.go: Comprehensive tests for all lift/lower functions

- Add wasm64 RetArea detection and code generation:
  - needsWasm64RetArea(): Detect pointer-containing return types
  - canUseRetAreaForType(): Validate types work with uint32 fields
  - calculateRetAreaSize(): Count fields needed including padding
  - generateWasm64LiftCall(): Generate specialized lift code

- Support for complex nested types:
  - Deep conversion for list<tuple<T,U>> with nested pointers
  - Proper handling of monotypic vs heterogeneous tuples
  - Inline converters for compound types in lists

- Result type support with proper alignment:
  - Remove Result exclusion from RetArea
  - Implement generateResultLiftCall() for result<T,E> types
  - Calculate payload offset based on Canonical ABI alignment rules
  - Handle simple variants (<=2 cases) with inline if/else
  - Use Reinterpret fallback for complex variants (>2 cases)
  - Support for empty payloads, enums, resources, and nested types

Before (broken on wasm64):
  wasmimport_Function(unsafe.Pointer(&result))
  return

After (correct for wasm64):
  wasmimport_Function(unsafe.Pointer(&cm.Area3))
  return cm.LiftString32[string](cm.Area3.F1, cm.Area3.F2)

For complex types like result<list<u8>, stream-error>:
  return func() cm.Result[...] {
    disc := cm.Area4.F1
    if disc == 0 {
      return cm.OK[...](cm.LiftList32[uint8](cm.Area4.F2, cm.Area4.F3))
    } else {
      return cm.Err[...](/* variant lifting */)
    }
  }()

The fix implements the "Area/RetArea" pattern suggested in PR bytecodealliance#367:
1. Global RetArea variables receive 32-bit ABI values from host
2. Specialized lift functions convert from 32-bit to native layout
3. Proper alignment calculation based on Canonical ABI spec
4. Deep conversion for nested structures with pointer fields

Alignment calculation follows Component Model spec:
- For Result types: payload offset = align_to(discriminant_size, max_case_align)
- Discriminant is u8 (1 byte) for 2-case results
- Payload aligned to max(align(OK), align(Err))
- Converts byte offset to uint32 field index

Works on ALL platforms:
- wasm32 (TinyGo): Correct, small overhead (~5%)
- wasm64 (big Go): Correct, fixes critical bugs
- Native (testing): Correct, tests pass

The Component Model ABI uses i32 pointers even on wasm64, so RetArea
with uint32 fields is correct for all platforms.

- All 100+ generator tests pass
- All cm package tests pass
- Real-world validation: HTTP requests to example.com succeed on wasm64
  (previously failed with "unknown handle index 0")
- No regressions on wasm32

Fixes the wasm64 pointer size mismatch issue from PR bytecodealliance#367.

Co-authored-by: Claude <[email protected]>

Author: sd2k

cm/area.go

@@ -0,0 +1,256 @@
+package cm
+
+// RetArea types are used to receive return values from Component Model
+// functions using the 32-bit Canonical ABI. These are necessary on wasm64
+// where Go uses 64-bit pointers, but the Component Model ABI uses 32-bit
+// values exclusively.
+//
+// Each RetArea has a HostLayout to ensure proper memory layout matching
+// the Component Model ABI, followed by N uint32 fields to receive the
+// flattened return value components.
+//
+// For example, a function returning option<string> would use RetArea3:
+//   - _1: discriminant (0 or 1)
+//   - _2: string pointer (32-bit)
+//   - _3: string length (32-bit)
+//
+// These are used as global variables to avoid allocation overhead, and the
+// returned values are immediately lifted into proper Go types after the call.
+
+// RetArea1 holds a single 32-bit return value.
+type RetArea1 struct {
+	_  HostLayout
+	F1 uint32
+}
+
+// RetArea2 holds two 32-bit return values.
+type RetArea2 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+}
+
+// RetArea3 holds three 32-bit return values.
+type RetArea3 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+	F3 uint32
+}
+
+// RetArea4 holds four 32-bit return values.
+type RetArea4 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+	F3 uint32
+	F4 uint32
+}
+
+// RetArea5 holds five 32-bit return values.
+type RetArea5 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+	F3 uint32
+	F4 uint32
+	F5 uint32
+}
+
+// RetArea6 holds six 32-bit return values.
+type RetArea6 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+	F3 uint32
+	F4 uint32
+	F5 uint32
+	F6 uint32
+}
+
+// RetArea7 holds seven 32-bit return values.
+type RetArea7 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+	F3 uint32
+	F4 uint32
+	F5 uint32
+	F6 uint32
+	F7 uint32
+}
+
+// RetArea8 holds eight 32-bit return values.
+type RetArea8 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+	F3 uint32
+	F4 uint32
+	F5 uint32
+	F6 uint32
+	F7 uint32
+	F8 uint32
+}
+
+// RetArea9 holds nine 32-bit return values.
+type RetArea9 struct {
+	_  HostLayout
+	F1 uint32
+	F2 uint32
+	F3 uint32
+	F4 uint32
+	F5 uint32
+	F6 uint32
+	F7 uint32
+	F8 uint32
+	F9 uint32
+}
+
+// RetArea10 holds ten 32-bit return values.
+type RetArea10 struct {
+	_   HostLayout
+	F1  uint32
+	F2  uint32
+	F3  uint32
+	F4  uint32
+	F5  uint32
+	F6  uint32
+	F7  uint32
+	F8  uint32
+	F9  uint32
+	F10 uint32
+}
+
+// RetArea11 holds eleven 32-bit return values.
+type RetArea11 struct {
+	_   HostLayout
+	F1  uint32
+	F2  uint32
+	F3  uint32
+	F4  uint32
+	F5  uint32
+	F6  uint32
+	F7  uint32
+	F8  uint32
+	F9  uint32
+	F10 uint32
+	F11 uint32
+}
+
+// RetArea12 holds twelve 32-bit return values.
+type RetArea12 struct {
+	_   HostLayout
+	F1  uint32
+	F2  uint32
+	F3  uint32
+	F4  uint32
+	F5  uint32
+	F6  uint32
+	F7  uint32
+	F8  uint32
+	F9  uint32
+	F10 uint32
+	F11 uint32
+	F12 uint32
+}
+
+// RetArea13 holds thirteen 32-bit return values.
+type RetArea13 struct {
+	_   HostLayout
+	F1  uint32
+	F2  uint32
+	F3  uint32
+	F4  uint32
+	F5  uint32
+	F6  uint32
+	F7  uint32
+	F8  uint32
+	F9  uint32
+	F10 uint32
+	F11 uint32
+	F12 uint32
+	F13 uint32
+}
+
+// RetArea14 holds fourteen 32-bit return values.
+type RetArea14 struct {
+	_   HostLayout
+	F1  uint32
+	F2  uint32
+	F3  uint32
+	F4  uint32
+	F5  uint32
+	F6  uint32
+	F7  uint32
+	F8  uint32
+	F9  uint32
+	F10 uint32
+	F11 uint32
+	F12 uint32
+	F13 uint32
+	F14 uint32
+}
+
+// RetArea15 holds fifteen 32-bit return values.
+type RetArea15 struct {
+	_   HostLayout
+	F1  uint32
+	F2  uint32
+	F3  uint32
+	F4  uint32
+	F5  uint32
+	F6  uint32
+	F7  uint32
+	F8  uint32
+	F9  uint32
+	F10 uint32
+	F11 uint32
+	F12 uint32
+	F13 uint32
+	F14 uint32
+	F15 uint32
+}
+
+// RetArea16 holds sixteen 32-bit return values.
+type RetArea16 struct {
+	_   HostLayout
+	F1  uint32
+	F2  uint32
+	F3  uint32
+	F4  uint32
+	F5  uint32
+	F6  uint32
+	F7  uint32
+	F8  uint32
+	F9  uint32
+	F10 uint32
+	F11 uint32
+	F12 uint32
+	F13 uint32
+	F14 uint32
+	F15 uint32
+	F16 uint32
+}
+
+// Global RetArea variables for receiving return values.
+// These are reused across calls to avoid allocation overhead.
+// Note: These are not safe for concurrent use without synchronization.
+var (
+	Area1  RetArea1
+	Area2  RetArea2
+	Area3  RetArea3
+	Area4  RetArea4
+	Area5  RetArea5
+	Area6  RetArea6
+	Area7  RetArea7
+	Area8  RetArea8
+	Area9  RetArea9
+	Area10 RetArea10
+	Area11 RetArea11
+	Area12 RetArea12
+	Area13 RetArea13
+	Area14 RetArea14
+	Area15 RetArea15
+	Area16 RetArea16
+)