Problem

LLGo keeps goroutine-owned runtime state in several pthread-backed locations:

• the active defer chain has its own pthread key;
• panic/recover and Goexit use additional pthread keys;
• main-goroutine detection uses a pthread identity comparison.

That splits one goroutine's state across unrelated lifetime mechanisms and makes each new field add more key management.

Change

Introduce one runtime g and one getg path:

type g struct {
	defer_ *Defer
	panic_ unsafe.Pointer
	goexit bool
	isMain bool
}

Hosted LLGo targets store *g behind one pthread key. getg lazily allocates a zeroed GC root, installs it with pthread_setspecific, and reuses it for defer, panic/recover, Goexit, and main state. The pthread-key destructor releases an outstanding panic value and the GC root.

Host builds and currently single-context bare-metal targets use the same g API with an ordinary global fallback.

This PR does not add compiler directives, locality metadata, package-block storage, or C-library constructor changes. It changes eight files and has an independent diff of +369/-73.

Relation to #2079

This PR and #2079 are independent and can merge in either order.

• If this PR merges first, compiler/runtime: add //llgo:tls and //llgo:gls package variables #2079 will be rebased and its runtime integration will adapt around the pthread-key getg.
• If compiler/runtime: add //llgo:tls and //llgo:gls package variables #2079 merges first, this PR will be rebased and the overlapping runtime-state implementation will be adapted to the merged locality facilities.

The current head deliberately uses pthread keys so it can be reviewed and merged without the larger TLS/GLS compiler change.

Runtime cost

Apple M4 Max, macOS arm64, Go 1.26.5, LLVM 19.1.7, real LLGo, five adjacent benchmark runs:

The benchmark reports 0 B/op, 0 allocs/op on the hot path. Allocation occurs once when a pthread first acquires its g.

Validation

Tests were serialized with GOMAXPROCS=2, GOMEMLIMIT=8GiB, and -p=1.

• macOS arm64, Go 1.26.5: runtime host compilation and real-LLGo test/llgoext pass.
• Ubuntu arm64, Go 1.26.5, LLVM 19.1.7: the same compiler/runtime tests pass in a container limited to 8 GiB, 2 CPU, no swap, and 512 PIDs.
• Integration coverage verifies stable getg within one goroutine, distinct state across concurrently live goroutines, defer-head isolation, and Set/Get/Clear transitions.
• No existing test is skipped or ignored.