fix: give a module its own API back, so it can call itself

[TomChv]

A module's generated bindings carried core and its dependencies but not itself,
so dag.<self>() did not exist and the self call was gone. The Go SDK has it —
internal/dagger/<self>.gen.go, sitting beside the dependency's.

Why it was missing

The schema a module's bindings are generated from is core plus its dependencies.
At generation time the module is defined by source that has not been compiled
yet, so its own API cannot be in it. The schema that does carry it is the
module's own client-facing one — and reading that means loading the module,
which needs the bindings that do not exist yet.

Two passes

Generation runs bindings, entrypoint and config as before, then the bindings
again with the module's own API folded in. The self target is resolved once
between the passes: it is not available until the first has written the files
that make the module loadable, and both halves of the scope need it.

Both passes run every time, from the same inputs, so the result does not depend
on what was on disk when the run started. Without that, a fresh module's first
generation had no self bindings and its second did, and dagger generate was no
longer idempotent — generate-idempotent-check catches exactly this.

Only the bindings are redone. The entrypoint comes from scanning the user's
source, which the self types do not change, and it is the expensive half.

A target like any other

The module's own API is rendered wherever a target is: its own file in the
module's bindings, so its source can call itself, and the standalone package, so
callers outside it can too.

sdk/                        clients/
├── client.gen.ts           ├── dagger.gen.ts
├── <self>.gen.ts           ├── <self>.gen.ts
├── hello.gen.ts            ├── hello.gen.ts
└── hello-world.gen.ts      └── hello-world.gen.ts

In the package it is a local target: the bootstrap serves it by resolving the
scope against the workspace, the same way it serves one that was added on
purpose. It is never a manifest dependency — a module does not depend on itself,
and the engine already serves it into its own session.

Every module therefore gets a clients/ directory, including one with no targets
of its own. That is an intermediate state: once clients are unified the two
directories merge into clients/ alone. Noted in design/module-max.md.

Splitting the module's own types out needs them attributed to it, and they carry
no sourceMap directive in its own client schema — only the Query field that
reaches them does. So the walk that collects them stamps them, which is what lets
the existing split, re-export and augmentation machinery treat them like a
dependency's. The module-facing schema separates the module's own types from the
core ones the walk passes through: core is already there.

The accessor was also PascalCase. Schema fields are camelCase by convention, so
this only surfaced on a module whose name starts with an underscore — the
underscore survives into the field name. Member names are now lowered at the
three sites that render a schema field as a TypeScript member; FormatName is
left alone because it also renders class and interface names. The wire name comes
from the raw field, so this changes what the caller writes, not what is selected.

Generated files must not be gitignored

Found while fixing the above, and it had been breaking dagger generate on every
run after the first. A CLI 1.0 module is built from committed generated files,
and the engine does not see files git ignores — so a fixture that ignored its own
sdk/ could not be loaded once those files existed on disk. A dependent failed
with committed generated file "sdk/client.gen.ts" is missing while the file sat
right there, and so did the module itself once generation started reading its own
schema.

It only shows up after a first successful run, which is why it read as flaky
state: on a clean tree the files are written into the workspace the generator
threads along and everything resolves.

Only the ignore rules change; the generated output stays untracked, which is what
the fixtures that never ignored it already do.

Verified

• generate-self-call-check covers both halves and the accessor casing, plus the
  existing 47 e2e checks and the helpers/* Go tests, from a clean tree.
• End to end against a dev engine in a real workspace: dag.<self>(), a remote
  client target and a local one all return values from the module they address,
  and dagger generate is idempotent across apply-and-regenerate.