Avoid test-only race workarounds and align test behavior with what
feldera client SDK users actually run.

Added client-side start observation (observe_start) for start(wait=False)
so callers can wait until lifecycle leaves STOPPED.

Removed deployment-status polling helper logic from platform tests and
switched helpers/tests to rely on Feldera client lifecycle APIs.

Polling for deployment-status transitions is now internal to FelderaClient
(_wait_for_deployment_status) instead of test helper code.

…latform tests

Use explicit condition polling instead of blind delays for logs,
connector state changes, checkpoint completion, and datagen progress.

This removes timing-based race masking, makes synchronization deterministic,
and makes each test wait state explicit about what condition must be reached.

…age polling

Replace test helper wait_for_cleared_storage() with FelderaClient.clear_storage(...)
This moves storage lifecycle synchronization to the client path used
by SDK users and removes duplicate test-side polling logic.

…rm tests

Expose compilation waiting as a client API with optional expected
program version, timeout, and poll interval.

Useful for users who run async create/update flows (wait=False) and
later need a deterministic compile barrier before start(), and for
patch/update workflows that must wait for a specific new program
version (not stale Success).

Unlike deployment-oriented waiter wait_for_status(),
this API tracks program lifecycle (program_status/program_version)
and fails fast on compile errors.

Raw ingress tests queried too early after async ingestion, causing
flaky failures.

Wait on completion tokens for successful ingests and explicitly poll for
CSV partial-ingest visibility in the BAD_REQUEST parse-error case.

Ensure waiters never block forever by normalizing None/infinite timeouts to
safe defaults across client, pipeline, HTTP health recovery, and test helpers.
Also standardize timeout measurements on time.monotonic() to avoid wall-clock
jumps affecting elapsed-time logic. This prevents hidden hangs while keeping
async operations deterministic under slow cluster conditions.

Replace test _wait_token() polling with client wait_for_token(...)
to align platform tests with feldera client behavior and remove
duplicate completion-status wait logic.

Switch timeout/elapsed polling paths in client and platform tests from
time.time() to time.monotonic() to avoid wall-clock jumps affecting wait
behavior. Keep time.time() in testutils_oidc.py because token expiry/cache
timestamps are wall-clock/epoch semantics, and in checkpoint-sync random
seeding where clock monotonicity is irrelevant.

Move generic condition polling from platform test helper into Feldera client as
FelderaClient.wait_for_condition(...), including timeout/poll validation and
usage docs. Keep test callsites stable by making helper a thin proxy to the new
client API.

Document usage with a new “Waiting for a Custom Condition” example
in python/docs/examples.rst.

This is another step in the wait-loop migration series to reduce async
start/stop/checkpoint race flakes and keep test synchronization aligned with
Feldera client behavior used by SDK users.

Replace remaining manual loops with wait_for_condition-based waits and clarify
helper usage: use helper wrapper only when no Pipeline object exists; otherwise
call pipeline.client.wait_for_condition(...) directly.

Update Python and docs.feldera.com docs for new client-side wait APIs and
lifecycle synchronization patterns:
 - document wait_for_program_success and wait_for_condition
 - add practical examples for async start and custom predicate waiting
 - clarify lifecycle async behavior and recommend SDK built-in methods over
   custom synchronization loops
 - fix typo: "predicate returns True when condition is met"