Background reconciliation and governance sync tasks could block for up
to 10 minutes per call on known-unsynced datalayer stores, and the V1
governance sync recursively retried up to 50 times on every failure.
This caused visible startup and task-cadence stalls.

- Add sync-status pre-checks to V1 and V2 reconcileOrganization: subscribe
  to the org store so it starts syncing, then skip reconcile on the next
  task run if either the org store or its derived singleton is unsynced.
- Replace recursive retry in V1/V2 governance sync with a single attempt
  per task invocation.  On failure the function logs and returns; the
  scheduler re-runs the task on its normal cadence, so the coroutine
  never blocks its scheduler slot.
- Skip governance sync immediately when the body store or its versioned
  governance store reports unsynced, preserving cached governance data.
- Keep the production wait-loop in getRegistryStoreIdFromSingleton so
  request-path callers (subscribe controller, import flow) still work
  on newly-discovered stores; the reconcile pre-check makes the wait a
  no-op on the background path.
- Standardize the governance sync interval to 300 seconds (5 minutes)
  across defaults, task fallbacks, example env, and test config.  The
  sync pre-check is a single lightweight RPC so running every 5 minutes
  is safe.
- Add focused tests for reconcile and governance non-blocking behavior,
  idempotency, and schedule configuration.

Bugbot flagged a permanent-skip loop in Governance.sync (both v1 and v2):
getDataLayerStoreSyncStatus returns false for a store the DataLayer node
has no record of, isDlStoreSynced(undefined) is false, sync() early-exits,
and because sync() was the only place that called
subscribeToStoreOnDataLayer (via getSubscribedStoreData), the store never
got subscribed and the skip repeated forever on every scheduled run.

Mirror the subscribe-first pattern already used in
OrganizationsV2.reconcileOrganization: subscribe first (idempotent), then
check sync status.  Applied to both the governance body store and the
versioned-governance store in both v1 and v2 models.

subscribeToStoreOnDataLayer returns false on the common
datalayer-unreachable / RPC-failure paths (it does not throw), so guard
on both a falsy return and thrown exceptions.  Without the falsy-return
check, the dominant failure mode would slip past the try/catch and the
subsequent status-check skip would fire with a misleading log.

Adds tests/v2/integration/governance-sync-subscribe-first.spec.js
covering five branches of GovernanceV2.sync:
- subscribeToStoreOnDataLayer runs before getDataLayerStoreSyncStatus on
  the body store
- sync() returns cleanly when the body-store subscribe throws
- sync() returns cleanly when the body-store subscribe returns falsy
- sync() subscribes to the versioned store before its status check (call
  order: body-subscribe -> body-status -> body-fetch -> versioned-subscribe
  -> versioned-status), and does not upsert when the versioned store is
  unsynced
- sync() returns cleanly when the versioned-store subscribe returns falsy

The v1 model captures USE_SIMULATOR at module import time so the same
test pattern cannot reach its production path; the v1 change is
structurally identical to v2 and is reviewed by code reading.

…falsy return

Bugbot flagged an inconsistency introduced by af06a65: governance sync
now correctly treats both a thrown exception and a falsy return from
subscribeToStoreOnDataLayer as a failure, but V1/V2 reconcileOrganization
still only guarded thrown exceptions.

subscribeToStoreOnDataLayer in src/datalayer/persistance.js returns
false (without throwing) on the two most common failure paths:
  - No storeId provided
  - getSubscriptions() RPC failure (datalayer unreachable)

Without the falsy-return check, the dominant datalayer-unreachable
failure slips past the try/catch, and the subsequent
getDataLayerStoreSyncStatus call (which also fails when the store is
not subscribed) produces a misleading "not yet synced" log instead of
a clear "could not subscribe" message.

Mirrors the subscribe-first pattern af06a65 added to governance sync.
Both subscribe-first and the falsy-return guard are no-ops in simulator
mode (wrapped in !USE_SIMULATOR for V2, skipped entirely for V1 via the
function's top-level simulator guard).

…ta loss

Bugbot flagged a High Severity regression on 6d41b71: reconcileOrganization
now silently returns (no throw) when a store is unsynced or the subscribe
call fails, but the user-facing resyncOrganization controller
(POST /organizations/resync and POST /v2/organizations/resync) calls
reconcileOrganization and then unconditionally:

  1. Resets registryHash / registry_hash to '0'
  2. Destroys ModelKeys rows (V1) / AuditV2 rows (V2) for the orgUid

Before this PR, reconcileOrganization would either complete or throw; the
throw would hit the controller's catch, roll back the transaction, and
return 400 without destroying data.  After 6d41b71, a transient datalayer
hiccup (subscribe returns false, sync-status RPC fails, etc.) causes the
resync endpoint to "succeed" with silent data deletion.

Fix: add a { skipOnUnsynced } option to both V1 and V2
reconcileOrganization.
  - Default (false): throw on any subscribe-failed / store-unsynced /
    status-check-failed condition.  Restores pre-6e76235 behavior for
    request-path callers.
  - true: silent skip with an INFO log.  Preserves the sync-blocking
    regression fix for background task callers
    (validate-organization-table-and-subscriptions*.js).

Background task callers updated to pass { skipOnUnsynced: true }.  The
two resync controllers are unchanged — they continue to call
reconcileOrganization with the (now throwing) default behavior, which
hits their existing catch block and rolls back the transaction.

Adds six contract tests covering the new option in simulator mode
(signature acceptance, no-option back-compat, no signature errors for
either value).  Production throw/skip behavior remains covered by live
integration tests; simulator mode cannot reach the pre-check block
(wrapped in !USE_SIMULATOR for V2, guarded at the top of the function
for V1).

…ned helper

Bugbot flagged a High Severity ReferenceError in my previous commit 9cf6cb7:
stale refactor code sitting in my worktree from an earlier exploration of a
`subscribeOrSkip` helper got swept into `git add -A` and landed in the
Organization.importOrganization method.  The helper was never defined,
never imported, and never exported — so the commit compiled but would
crash at runtime with `ReferenceError: subscribeOrSkip is not defined`
on the first non-simulator-mode call to importOrganization.

importOrganization is out of scope for this PR; its improvements live in
#1603.  Revert that function's "Subscribe to the org store first, then
check sync status" block to match origin/v2-rc2 verbatim.  All
intentional #1600 changes (reconcileOrganization + skipOnUnsynced,
governance sync, task intervals, tests) are untouched.

Verified by `git diff origin/v2-rc2 -- src/models/organizations/organizations.model.js`
now showing only reconcileOrganization changes.