feat: add value-expression AST nodes for composing call chains

[Emyrk]

Adds seven bindings nodes that let mutations build TypeScript value expressions structurally instead of via string concatenation:

Node	Emits
IdentifierExpression{Name}	z, BaseSchema (bare value reference)
PropertyAccessExpression{Expr, Name}	expr.name
CallExpression{Expr, Args}	expr(args...), composes for chains
ObjectLiteralExpression{Props} + PropertyAssignment{Name, Init}	{ k: v, ... } in value position
ArrowFunction{Params, RetType, Body} + Parameter{Name, Type}	(params): retType => body
TypeQuery{Name}	typeof Name (type position)

Foundation for a stacked PR that adds a zod mutation; useful on its own to any caller that wants to inject computed value expressions into the AST.

Implementation notes and test coverage

Why these aren't covered by existing nodes

• ReferenceType is a TypeScript type-reference node. IdentifierExpression is needed for the value-position case (the z in z.string()); reusing ReferenceType there would emit a type reference where TypeScript expects an expression.
• TypeLiteralNode is a TypeScript object-type literal ({ k: string }). ObjectLiteralExpression is its value-position sibling ({ k: z.string() }). They share no semantics so they stay distinct.
• ArrayLiteralType and LiteralType already cover [...] and primitive literals, so this PR doesn't redefine them.

Wiring

• ts.factory.create* wrappers added to typescript-engine/src/index.ts. dist/main.js rebuilt with pnpm run build.
• Goja-backed builders added to bindings/bindings.go.
• ToTypescriptNode dispatches *PropertyAssignment and *Parameter directly (neither is an ExpressionType or DeclarationType because they only appear as children of object literals / arrow functions).
• ToTypescriptExpressionNode dispatches the six new ExpressionType cases.

Test coverage

bindings/expressions_test.go round-trips every node through goja and verifies the emitted text:

• TestIdentifierExpression — bare identifier.
• TestPropertyAccessExpression — z.string.
• TestCallExpression — no-args, one-arg, chained (z.string().optional()), and nested (z.array(z.string())).
• TestObjectLiteralExpression — empty, single property, multiple with declaration-order preservation.
• TestPropertyAssignment — standalone, easier failure bisect.
• TestArrowFunction — no params, with return type, with typed parameter.
• TestTypeQuery — standalone and as a generic argument (Foo<typeof FooSchema>).
• TestComposeZodObject and TestComposeZodLazyRef — integration cases that build the z.object({...}) and z.lazy((): z.ZodType => Schema) shapes the stacked zod mutation will need. If these fail, the follow-up cannot succeed.

go test ./... and go vet ./... clean (one pre-existing unreachable-code warning in convert.go predates this branch).

Stacked follow-up

A feat/zod-mutation PR will add a zod package with an AsSchemas mutation that walks every Interface / Alias in ts.typescriptNodes and replaces it with a VariableStatement (export const FooSchema = z.object({...})) plus an Alias (export type Foo = z.infer<typeof FooSchema>). The schema expression tree is built from the nodes in this PR. Replaces #82's string-builder serializer with an AST mutation composable with ExportTypes, SimplifyOptional, and the other config mutations.

---

Generated by Coder Agents on behalf of @Emyrk.