ctypes: unify the foreign-call path on a single host_env call() API - #8235

Replace the VM's direct libffi `Type`/`Arg` marshalling with the unified
host_env `call` entry point. Behavior is preserved on the tested paths:
structs and unions still pass by pointer and struct returns still use the
register-size approximation (passing/returning aggregates by value is a
later change).

- base.rs: `FfiArgValue` → `CArgValue` (Typed{code,bytes}/Int/Double/Pointer)
  with `as_call_arg()`; the paramfunc producers emit `CArgValue`, snapshotting
  buffer bytes at conversion time so no lock is held across the call.
- _ctypes.rs: `CArgObject` carries `value: CArgValue` plus a `keep` slot for
  the from_param z/Z/P null-terminated-copy keepalive that no longer rides in
  the value; `PyCArg` repr reconstructs the scalar for identical output; byref
  updated.
- simple.rs: `to_ffi_value` → `to_carg_value`; from_param emits `CArgValue`
  and its keepalive.
- function.rs: `Argument{value, keep}`; `ArgumentType` yields a `CArgValue`
  (with the "unsupported argument type" check moved up front); `CallInfo`'s
  return fields collapse to `RetSpec` (Void/Pointer/Code) reproducing the exact
  return type and result dispatch; `ctypes_callproc` builds `CallArg`/`CallRet`/
  `CallOptions` and invokes `host_env::ctypes::call`; the errno/last-error swap
  moves into `CallOptions` (the `with_swapped_*` wrappers are removed);
  `convert_raw_result` consumes `CallValue`.
- extra_tests/snippets/stdlib_ctypes_calls.py: libc calls over the live FFI
  path (abs/strlen/sqrt, c_char_p/c_void_p returns, a use_errno round-trip);
  output matches CPython.

Two intentional deltas: a NULL function pointer now raises ValueError instead
of a debug assertion, and a c_char passed positionally without argtypes now
zero-extends via its type code rather than sign-extends via the old tag path,
which also makes it agree with the with-argtypes path.

The old host_env `callproc`/`ffi_*` and `StgInfo`'s libffi field types remain
for now; they are removed when by-value aggregates land.

Assisted-by: Claude

Flip aggregate arguments and returns from the pointer / register-size
approximation to true by-value passing through the host_env `call` entry
point, and carry the driving layouts as host_env `CTypeLayout`.

- base.rs: `StgInfo.ffi_field_types: Vec<FfiType>` becomes
  `field_layouts: Vec<CTypeLayout>`, still built incrementally from the base
  class so struct inheritance is reflected. `StgInfo::to_ffi_type()` is
  replaced by a `type_layout(ty, &stg, vm)` helper that reads a type's own
  layout (aggregates from `field_layouts`, arrays recurse into the element
  type, simple types from their `_type_` code); it takes the already-borrowed
  `StgInfo` so it never re-locks the type. `CArgValue` gains an
  `Aggregate { layout, bytes }` variant lowering to `CallArg::Aggregate`, and
  `struct_union_paramfunc` snapshots the instance bytes into it (tag 'V').
- structure.rs / union.rs: collect each field's `type_layout` into
  `field_layouts` and store it on the finalized `StgInfo`.
- function.rs: `convert_object` passes a struct/union argument by value
  (snapshot bytes + argtype layout); a `byref()` result is still a pointer.
  `RetSpec` gains `Aggregate(CTypeLayout)`; `compute_ret_spec` returns it for
  a struct/union restype; `ctypes_callproc` lowers it to `CallRet::Aggregate`.
  `convert_raw_result` now drops the restype `StgInfo` read guard before
  constructing the result instance: instance construction write-locks the
  type's `StgInfo` to finalize it, which otherwise self-deadlocks against the
  held read guard (latent since the register-size return path, unreachable
  until a struct was actually returned by value).
- _ctypes.rs: a 'V' cparam now reprs as `<cparam 'V' at 0x..>` (the
  object-address default), matching PyCArg_repr; the aggregate `CArgValue`
  routes through that arm.
- extra_tests/snippets/stdlib_ctypes_byvalue.py: div/imaxdiv struct returns
  (8- and 16-byte), inet_ntoa struct and union arguments, with and without
  argtypes; output matches CPython. Also sorts the imports in the sibling
  stdlib_ctypes_calls.py snippet (ruff isort).

`_pack_` / `_swappedbytes_` layouts stay approximate — `CTypeLayout` carries
no explicit field offsets, as the previous libffi field-type path did not
either. host_env is untouched, so both `ctypes.rs` copies stay byte-identical.

test_ctypes is unchanged at run=322 skipped=58.

Assisted-by: Claude

With the VM `_ctypes` and pyre both routed through `call`, delete the
foreign-call paths and libffi-type builders that no longer have a consumer:

- `callproc` (the low-level libffi `Vec<Type>` / `&[Arg]` entry) and its
  `CallResult` return type plus `call_result_bytes`.
- `callproc_simple` and its `SimpleArg` / `SimpleRestype` / `SimpleCallError`
  types (the pointer-only slice added for pyre's first cut), and the
  `lookup_function_symbol_addr_str` helper, along with their tests.
- `ffi_type_for_layout` + `CTypeParamKind`, `ffi_type_from_format`,
  `ffi_type_from_tag`, and `ffi_type_for_return_size` — the aggregate/simple
  libffi-type builders the old marshalling used. `call` and `CTypeLayout`
  build their own libffi types from `ffi_type_from_code` and the small
  `ffi_{pointer,byte_struct,repeat,void,i32,f64}_type` helpers, which stay.

`simple_type_chars` stays (still used by pyre's simple-type validation). The
`call` doc no longer references `callproc_simple`. A stale comment in the VM's
result decoder that named `call_result_bytes` is reworded.

host_env drops from 4051 to 3535 lines; the `call` ABI unit tests remain
(24 tests). test_ctypes is unchanged at run=322 skipped=58.

Assisted-by: Claude

`stdlib_ctypes_byvalue.py` reaches libc through `CDLL(None)` and calls
`div`/`imaxdiv`/`inet_ntoa`, none of which resolve that way on Windows,
so the snippet aborted on windows-2025. Guard it like
`stdlib_ctypes_calls.py`: print "OK" and exit before touching `CDLL`.
The by-value path is covered on Windows by test_ctypes.

Assisted-by: Claude

A zero-sized `Structure`/`Union` argument reaches the aggregate lowering
with `layout.size() == 0` and an empty buffer, which passed the
`buffer.len() < expected` check and then panicked on `&buffer[0]`. Use
`buffer.first().unwrap_or(&0u8)`; libffi reads nothing for a zero-size
type.

Assisted-by: Claude