purego: add various performance optimizations

[tmc]

What issue is this addressing?

#399

What type of issue is this addressing?

performance

What this PR does | solves

Summary

This reduces per-call overhead in RegisterFunc and callback dispatch through five targeted optimizations. All changes are internal — no public API changes, no behavioral changes. The heaviest wins come from eliminating repeated reflect.StructOf calls and heap allocations in the Darwin ARM64 stack-packing path.

• Cache reflect.StructOf results and pool struct instances in bundleStackArgs to avoid recreating packed struct types on every call
• Stack-allocate the []reflect.Value args slice in callbackWrap instead of heap-allocating via make, eliminating the single largest allocator identified in profiling (38.5% of total allocs)
• Remove defer from the RegisterFunc hot path, replacing deferred runtime.KeepAlive and thePool.Put with explicit calls after the syscall returns
• Pre-compute a per-function argKind enum slice at registration time so the per-call dispatch switches on a uint8 instead of calling reflect.Kind() repeatedly
• Pre-compute Darwin ARM64 bundle info (struct cache key, field indices, sync.Pool) at registration time to eliminate per-call cache key construction and sync.Map lookups

Benchmark results

Apple M4 Max, darwin/arm64, benchstat over 6 runs at 100ms each:

                                               │  baseline  │             after              │
                                               │   sec/op   │   sec/op    vs base            │
RegisterFunc/CFunc/1args-16                       159.5n ±1%   154.6n ±2%   -3.10% (p=0.002)
RegisterFunc/CFunc/5args-16                       233.8n ±2%   222.5n ±2%   -4.85% (p=0.002)
RegisterFunc/CFunc/10args-16                      802.9n ±1%   451.6n ±2%  -43.76% (p=0.002)
RegisterFunc/CFunc/15args-16                     1845.0n ±3%   564.4n ±2%  -69.41% (p=0.002)
RegisterFunc/Callback/5args-16                    483.0n ±1%   455.0n ±1%   -5.81% (p=0.002)
RegisterFunc/Callback/10args-16                   714.9n ±1%   652.0n ±1%   -8.79% (p=0.002)
RegisterFunc/Callback/15args-16                   912.8n ±2%   829.6n ±1%   -9.12% (p=0.002)
SyscallN/Callback/5args-16                        298.8n ±1%   283.8n ±1%   -5.02% (p=0.002)
SyscallN/Callback/10args-16                       423.1n ±1%   386.8n ±1%   -8.57% (p=0.002)
SyscallN/Callback/15args-16                       539.0n ±2%   497.6n ±1%   -7.66% (p=0.002)
geomean                                           264.2n       233.0n      -11.83%

                                               │  baseline   │             after              │
                                               │    B/op     │   B/op     vs base             │
RegisterFunc/CFunc/10args-16                      896.0 ±0%    464.0 ±0%  -48.21% (p=0.002)
RegisterFunc/CFunc/15args-16                     3098.0 ±0%    648.0 ±0%  -79.08% (p=0.002)
RegisterFunc/Callback/5args-16                    336.0 ±0%    208.0 ±0%  -38.10% (p=0.002)
RegisterFunc/Callback/10args-16                   600.0 ±0%    360.0 ±0%  -40.00% (p=0.002)
RegisterFunc/Callback/15args-16                   928.0 ±0%    544.0 ±0%  -41.38% (p=0.002)

                                               │  baseline  │            after              │
                                               │ allocs/op  │ allocs/op  vs base            │
RegisterFunc/CFunc/10args-16                      23.00 ±0%   16.00 ±0%  -30.43% (p=0.002)
RegisterFunc/CFunc/15args-16                      44.00 ±0%   21.00 ±0%  -52.27% (p=0.002)
RegisterFunc/Callback/5args-16                    10.00 ±0%    9.00 ±0%  -10.00% (p=0.002)
RegisterFunc/Callback/10args-16                   15.00 ±0%   14.00 ±0%   -6.67% (p=0.002)
RegisterFunc/Callback/15args-16                   20.00 ±0%   19.00 ±0%   -5.00% (p=0.002)

Low-arg-count paths (1 and 5 args for CFunc) are modestly faster since they don't hit the struct-packing path. The big wins are on 10+ arg calls where Darwin ARM64 stack bundling dominates.

Test plan

• go test ./... passes on darwin/arm64
• Verify no regressions on amd64 (struct_amd64.go signature change is a no-op stub)
• Review struct_arm64.go caching logic for correctness with concurrent callers (uses sync.Map + sync.Pool)
• Confirm callback paths are unaffected (bundling is guarded by !isCallback)