Fix silent reconciler skips on lock contention

[ideaship]

Summary

Fix explicit inventory reconciliations that silently skip when they cannot
acquire the reconciler lock, leaving osism sync inventory waiting for output
that will never arrive.

Also make related reconciler failure paths publish terminal output, return a
non-zero CLI result when the output wait itself times out, and prevent explicit
and periodic reconciler processes from rewriting the inventory concurrently.

Problem

osism sync inventory dispatches an explicit reconciler.run task and waits
for a terminal marker in that task's Redis output stream.

Previously, reconciler.run attempted to acquire its lock for 20 seconds. If
the lock remained held, the task skipped its entire body, published no terminal
marker, returned None, and was recorded by Celery as successful. The waiting
CLI could not distinguish that silent skip from a still-running task, so it
remained blocked until its configured task-output timeout.

This occurred during a deploy when seven reconciler tasks were dispatched in a
short burst. Five tasks silently skipped after approximately 20 seconds. The
CLI was waiting on one of those tasks with --task-timeout 1800, so the deploy
blocked for the full 30 minutes before the output wait timed out and aborted
the deploy.

Simply failing after the lock timeout is insufficient. The current lock holder
may have started before the caller's inventory changes existed, so the explicit
sync request must eventually execute its own reconciliation.

Changes

• Return a non-zero CLI result when waiting for reconciler output times out.
• Retry an explicit reconciler task up to five times at fixed five-second
  intervals when it cannot acquire the lock.
• Requeue the same Celery task ID so the waiting CLI continues following the
  correct output stream.
• Publish non-terminal retry status messages so users see the contention and
  the output inactivity deadline is refreshed.
• Publish a non-zero terminal result after retry exhaustion and preserve the
  Celery failure state.
• Guard explicit reconciliation failure paths so subprocess startup, output
  handling, process timeout, and task-lock failures publish terminal output
  when possible.
• Kill and reap /run.sh after its existing 60-second process wait expires,
  and always release an acquired lock.
• Use one execution lock key for explicit and periodic reconciler tasks.
  Explicit tasks retry on contention; periodic tasks continue to coalesce by
  skipping a contended run.

Scope limits

Terminal output publication remains best-effort. If Redis itself is
unavailable, the task cannot publish a terminal marker.

This change preserves the existing 60-second lock auto-release time. Extending
the lease for reconciliations that run longer than 60 seconds is outside this
PR's scope.

Testing

• Unit tests cover CLI output-wait timeout failure.
• Unit tests cover contention retries, status publication failures, retry
  exhaustion, and no-wait behavior.
• Unit tests cover subprocess and task failure cleanup paths.
• Unit tests verify explicit and periodic tasks use the same execution lock.
• Full test suite, Black, and flake8 pass.