feat(commands)!: defineCommand migration, lazy registration, in-process dispatch and command-owned key shortcuts - #6153

Platform validation, dynamic delegation, native-add and widget, test,
create/install/post-install-cli/help, enforced-parameter, device,
self-contained, platform, plugin and hooks, open|*, and the rest.
Class-based surfaces the migration left without callers are deprecated
rather than removed, since extensions may import them.

… type

registerCommand takes one shape and registers in one call, off the
global binding and into the loading context's injector; built-in
commands load on first use through a shared helper; getInjector becomes
getRootInjector. Package-manager commands register from their real
path, dev-post-install is reachable again, and a mistyped subcommand
shows help in the terminal.

A command can run another in process without exiting on failure; a
definition's setup state is scoped to one invocation;
DeferredCommandResult is a discriminated union; the command-name types
an extension needs are exported from the contracts.

BREAKING CHANGE: ctx.arguments is now ctx.params on the command context.

ns start's key handling becomes a declarative table over a
caller-supplied context, with state on the context and capabilities on
the injector; the key-command surface leaves the injector facade.
Failures from the spawned run children surface in the parent, and
NS_NO_OPEN keeps the CLI from launching a browser where nobody is
watching.

KeyShortcutRegistry is a contract with disposable registrations; the
engine resolves help and dispatch through it, so an entry registered at
runtime takes effect immediately. The shared entries become builders, a
defineCommand may declare the keys it answers to, and ns run and ns
debug get their own tables behind NS_COMMAND_SHORTCUTS (default off).

Stopping a bundler only sent SIGINT and returned, so a restart could spawn
a replacement while the old watcher was still alive. The stale child's exit
then evicted the replacement's map entry, and a compilation finishing on it
still reached the prepare controller.

Await the child's exit (escalating to SIGKILL), detach its output and IPC
handlers, and key every eviction on process identity. The prepare
controller now keeps its compilation handler per platform, so stopping one
platform no longer leaves the other's listener attached.

r restarts the app of the running session without preparing, building
or syncing; R prepares again first and rebuilds the native app only if
needed; B always rebuilds it. The help hint is repeated once a burst of
syncs settles, and a restart stays on the devices the session was given
instead of every device attached to the platform.

…oken

The adapter now builds a child injector per invocation providing
COMMAND_CONTEXT, and runs setup, canExecute, run, postRun and shortcuts
under it. Handler signatures are unchanged; the token is the way a
service or a field initializer reaches the context without threading it
through. The provider reads the stage's own context, and nothing outside
an invocation can resolve the token.

Command(meta) returns a base class whose static definition is a real
defineCommand result: the handlers become methods, the instance is the
setup result, and the adapter still only ever sees definitions. The
definition is a static getter, so it resolves the subclass it is read
through and caches on that constructor.

Registration, the name-literal check and the extension manifest path
take either form. COMMAND_CONTEXT is promoted to nativescript/contracts,
which is what the base class reads in its field initializer.

platform|clean, update and device|*list are written as Command()
classes, with their services as inject() fields and the constructor
doing the initializeProjectData() work setup did. The per-platform
device listings stay in the object form: they are generated from one
function, which is what that form is for.

canExecute opens the invocation with the context it builds; execute and
postCommandAction reuse it, so every stage, the class instance and
COMMAND_CONTEXT hold the same object.

canExecuteCommand(name, args) resolves a registered command and primes its
options exactly as runCommand does, then returns its own canExecute verdict.
The child builds its setup from its own services, so a command can reuse
another's precondition without importing its handlers.

The commands with real internal structure - state shared between canExecute
and run, values derived once per invocation, several private steps - are
classes now, with one inject() field per dependency and the handlers as
methods. Long handlers are split into private methods along the seams that
were already there.

EmbedCommand asks prepare whether it could run instead of importing its
canExecute, which is what canExecuteCommand exists for.

A simple command is now one defineCommand call with its handlers written
inline, where ctx is typed by inference: the exported setupX/runX/canExecuteX
functions and the IXServices and XCommandContext aliases nothing else read are
gone. Handlers inject what they use at their own top, before the first await.

No command hands another a bag of services any more. injectPlatformCommandServices
and the setupX bundles are deleted; the shared platform checks take the context
and resolve through ctx.injector. A setup that survives is side-effect only -
the eager initializeProjectData that has to land ahead of the arguments policy.

Says that a handler resolves its own dependencies at its top, that services
are never bundled or shared between commands, and that setup is optional sugar
for one command. Documents canExecuteCommand as the way to reuse another
command's precondition, and sharpens which authoring form fits which command.

CommandsService is the API a command or plugin runs or consults another
command through: runCommand and canExecuteCommand take the registered
name or the definition or class it was registered from. The free helpers
stay as convenience over it; the *InProcess methods are deprecated.

A name is looked up in the registry; a definition or Command() class is
built and run as the caller holds it, registered or not, its first name
serving only hooks and reporting.