fix: make bundle step refresh rollback transactional - #4827

Installed-step refresh with network access now snapshots the package and
registry entry, copies the backup, and removes the step inside
_step_install_transaction, using command_remove._remove_step_locked so
the same non-reentrant flock is not taken twice, while the catalog
reinstall stays outside the lock. On BundlerError, rollback acquires
that lock again, rereads step-registry.json, and restores the backup and
the original metadata only when the step id is missing, assigning the
saved entry verbatim so installed_at and updated_at stay unchanged. When
the id is already present, the later package and the rest of the reread
registry are left in place. A failed copy or registry write is attached
with add_note and the original install error is re-raised with the
backup kept on disk; lock failure before a snapshot is wrapped as
BundlerError, offline and not-yet-installed refresh still delegate to
install without a backup, and the tests assert those lock, concurrency,
and error-preservation paths.

Fixes github#4815

Assisted-by: AI

Rollback read step-registry.json directly, which bypassed StepRegistry's
symlink checks. It now reloads through StepRegistry._load and resolves
the steps base with resolve_steps_base_dir, _resolve_step_dir and
_reject_unsafe_destination before removing or copying the package, so a
steps directory or step directory swapped for a symlink during the
unlocked reinstall is refused and the backup is kept.

Adds tests for the initial lock failure (wrapped, no backup), a failed
rollback lock (original error kept with a note and the backup), and both
symlink swaps.

Assisted-by: Grok Build (model: unknown) and Claude Code (model: Claude Opus 5.5), autonomous
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019wSaUMZrtm6XSzwEcxavkv

refresh() decided the step was installed from the registry loaded at
manager construction. If a concurrent step remove committed before the
refresh transaction took its lock, the locked snapshot had no entry but
refresh still called _remove_step_locked, which reported "not installed"
and failed. The locked registry entry is now the deciding check: when it
is absent, refresh leaves the transaction without a backup and delegates
to install, which takes the same lock itself.

Adds a regression test that commits the removal just before the first
lock acquisition and checks that remove is not called, install runs once
outside the lock, and no refresh backup is created.

refresh() used StepRegistry.get() to decide whether the step was
installed, but get() returns None both for an absent id and for a key
whose value is JSON null. A null entry therefore skipped the snapshot
and removal and fell through to the non-force install path, which
rejects the id as already installed, and rollback skipped restoring a
None snapshot.

Installed-ness is now key membership via is_installed(), and the
snapshot is tracked by a separate flag so rollback writes a null value
back verbatim. Adds a regression test that seeds a null entry, fails
the reinstall, and checks the key, the null value and the package are
restored.

…r the lock

A BundlerError from _remove_step_locked was raised before the rollback
handler, so the finally block deleted the backup. Since the removal drops
the registry key before deleting the directory, a failed rmtree could lose
a JSON null entry and the step files. The removal error now goes through
the same rollback path as a failed reinstall: the snapshot is restored, or
kept on disk and named in the error if the restore fails.

Online refresh also no longer decides presence from the registry loaded at
manager construction. Only offline refresh skips straight to install;
online refresh reads the registry under _step_install_transaction, so a
step added after construction is snapshotted, removed and reinstalled
instead of failing check_installable().

Adds regression tests for a removal failure on a null registry entry and
for a step committed after the manager was built.