support static value members for named types

[KurodaKayn]

Problem Description

XGo is adding static member declarations for values, related to:

• Proposal: Static Members xgo#2513
• feat(syntax): add static value declarations xgo#2783
• parse static value names xgo#2792

The semantic layer currently needs to support declarations and references such as:

type foo int

const foo.name = "xgo"
var foo.count int = 100

a := foo.name
foo.count++

A first implementation was attempted in xgo/cl, but it requires a relatively large amount of name resolution logic there. Since gogen already owns type/member resolution for generated code, static value member resolution should preferably be supported in gogen itself.

Current Behavior

gogen already supports static methods through the XGos_Type_Method convention. For example, imported symbols with names like XGos_T_Method can be exposed as static methods on T.

However, there is no equivalent support for static value members:

• no API to register a package-level const or var as a static member of a named type
• cb.Typ(T).MemberVal("name", ...) only resolves methods on T, not associated package-level const/var objects
• MemberRef cannot resolve a static var member as an assignable reference
• imported package symbols such as XGos_T_name are not exposed as static value members on T

Because of this, XGo static member support currently has to manually rewrite and resolve T.name in cl.

Expected Behavior

gogen should provide a common mechanism for static value members associated with named types.

For example, after declaring or importing a static value member for foo.name, the following should work through normal member resolution:

cb.Typ(fooType).MemberVal("name", 0) // resolves to the associated const/var object
cb.Typ(fooType).MemberRef("count")   // resolves to an assignable static var reference

Generated Go should keep using package-level symbols, for example:

const XGos_foo_name = "xgo"
var XGos_foo_count int = 100

And references should compile to:

a := XGos_foo_name
XGos_foo_count++

Suggested Solution

Add first-class support in gogen for static value members, similar to existing static method support.

Possible implementation direction:

1. Add an API such as NewStaticMember / NewStaticValue / NewStaticVar / NewStaticConst to associate a types.Object with a *types.Named receiver and a member name.
2. Extend CodeBuilder.Member / findMember so TypeType receivers can resolve static value members, not only static methods.
3. Extend MemberRef so static vars can be used as assignable references.
4. Extend import handling so package-level symbols following the static member naming convention, e.g. XGos_T_name, can be registered on type T.
5. Keep static methods and static values in a consistent namespace, or document the intended collision behavior.

Acceptance Criteria

• cb.Typ(T).MemberVal("name", 0) resolves a registered static const or var.
• cb.Typ(T).MemberRef("count") resolves a registered static var and supports assignments/inc/dec.
• Imported XGos_T_name style symbols can be exposed as static value members.
• Local/instance selector behavior remains unchanged; instance fields and methods should still take precedence where applicable.
• Tests cover const, var, assignment/inc-dec, imported static members, and collision behavior with static methods.

Related Context

This would allow XGo static value member semantics to keep most name resolution inside gogen, instead of duplicating that logic in xgo/cl.