feat(analyzer): a union parameter names a type instead of resting at any

[giraffesyo]

Closes #87.

- name: either
  in: query
  schema:
    anyOf: [{ type: string }, { type: integer }]

type ListItemsParams struct {
	Either *any `json:"either,omitempty"`   // before
}

Assignable, since everything satisfies any, but nothing in the generated package said what was valid. This is the tail of #16.

Why it was blocked, and what unblocked it

#82 deliberately withheld the name hint here. Synthesizing the type is easy; the problem is that a union is a struct, and the query encoder writes a struct as an object, so either=42 would have gone out as the wrapper's shape. Typing the field would have made the wire wrong.

Every generated union now answers an unexported marker:

func (u ListItemsEither) unionValue() any { return u.Value }

and derefParam, which every parameter encoder already goes through, unwraps it:

if u, ok := rv.Interface().(unionValuer); ok {
	return derefParam(u.unionValue())
}

One place, so query, header, path, and cookie parameters all benefit. An unexported method rather than sniffing for a struct with a field named Value, which a schema could legitimately declare.

With the wire correct, the analyzer passes the hint:

either := ListItemsEither{Value: 42}
client.ListItems(ctx, ListItemsParams{Either: &either})   // ?either=42

Behavior worth knowing

• Unwrapping happens before the style is applied, not instead of it, so a list variant still explodes and a deepObject object parameter still explodes.
• A union carrying nothing sends no parameter, rather than a zero of some variant's type.
• One shape is one type. Two parameters declaring the same union share it, so a header parameter reuses the type a query parameter named. That also means a path parameter's type can be named after the operation that declared the shape first: GetItem(ctx, id ListItemsEither). Existing behavior for inline unions, now visible in a signature.
• Nullable unions are untouched: anyOf: [string, null] still collapses to *string.
• Inline objects in parameters ride along, since they were hintless for the same reason, and still encode under their style.

Tests

• internal/analyzer/operations_test.go: a union parameter names a union type, two parameters of one shape share it, a nullable union still collapses to string, and an inline object parameter is named.
• internal/generator/e2e_union_param_test.go: compiles and runs against httptest, checking an integer variant arrives as 42 and a string variant as abc, a list variant still explodes, header and path parameters unwrap too, an empty union sends nothing, a deepObject inline object explodes into at[lat] and at[lon], and a plain parameter is unaffected.

One existing expectation changed: TestNullableUnion_QueryParamsResolveToTheVariantType asserted that a real choice stays any, which was the behavior this replaces.

gofmt, go vet ./..., and go test ./... pass.