…shutdown

threadPoolCallbackRunnerUnsafe wrapped work in a std::packaged_task and scheduled
it on a ThreadPool. When the pool is shut down (ThreadPool::finalize sets shutdown
and the worker drains the queue with job_data.reset()), a still-queued task is
destroyed without running. The bare packaged_task then destructs its std::promise
with no stored value, so ~promise() stores a broken-promise std::future_error.

std::future_error derives from std::logic_error, so when a waiter observes it via
future.get() the server reports it through getCurrentExceptionMessageAndPattern,
which calls abortOnFailedAssertion on any std::logic_error in debug/sanitizer
builds, aborting the process during shutdown.

Observed in CI as a Stress test / serverfuzz abort (STID 2508-38c6): a TaskTracker
flush task scheduled through threadPoolCallbackRunnerUnsafe was dropped on shutdown,
and the waiting merge task aborted with "The associated promise has been destructed
prior to the associated state becoming ready".

Replace the packaged_task with a small runnable that owns its std::promise and, when
it is destroyed without having run, satisfies the promise with a normal DB::Exception
(CANNOT_SCHEDULE_TASK) instead of leaving it broken. DB::Exception is not a
std::logic_error, so the waiter now observes an ordinary, catchable error and the
server no longer aborts. This mirrors the explicit-promise handling already used by
the sibling ThreadPoolCallbackRunnerLocal (PR ClickHouse#73629) and preserves the existing
ThreadGroupSwitcher-before-set ordering and the SCOPE_EXIT_SAFE callback release.

Add a unit test that deterministically drops queued runner tasks on shutdown and
asserts their futures never carry a broken-promise std::future_error.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

The new gtest's catch (...) around pool.wait() tripped the catch_all style
check (silently swallows). pool.wait() rethrows only the blocker job's
std::runtime_error, so catch the concrete std::exception instead; anything
unexpected now propagates and fails the test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

… construction throws

Addresses review feedback on the broken-promise fix: CallbackRunnerTask's
destructor constructed the DB::Exception as the argument to make_exception_ptr,
outside any guard. Constructing a DB::Exception captures a stack trace and may
itself throw (e.g. std::bad_alloc under shutdown memory pressure); the surrounding
catch (...) then swallowed it and the std::promise destructed with no stored
value, recreating the broken-promise std::future_error this class is meant to
prevent.

Build the exception_ptr inside its own try first and, if constructing the intended
DB::Exception fails, fall back to std::current_exception() (always non-null inside
a catch handler). The promise is then unconditionally satisfied via set_exception,
so the dropped-task path can never leave it unset.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>