DelegatingSecurityContextScheduledExecutorService causes silent task termination when delegate throws exception

Describe the bug
When using DelegatingSecurityContextScheduledExecutorService to wrap a ScheduledExecutorService, any exception thrown by the delegate task propagates out of the DelegatingSecurityContextRunnable wrapper.

According to the ScheduledExecutorService contract (specifically scheduleAtFixedRate and scheduleWithFixedDelay), if any execution of the task encounters an exception, subsequent executions are suppressed.

Because DelegatingSecurityContextRunnable.run() uses a try-finally block (to clear the context) but does not catch exceptions, a single transient error in a secured scheduled task causes the entire schedule to silently stop forever. No error log is produced by default, leading to a "Silent Failure" (ENC - Exception Not Caught pattern).

To Reproduce
Steps to reproduce the behavior:

1. Create a standard ScheduledExecutorService.
2. Wrap it with DelegatingSecurityContextScheduledExecutorService.
3. Schedule a task that throws a RuntimeException.
4. Observe that the task runs once and then never runs again.

Expected behavior
While DelegatingSecurityContextRunnable correctly prioritizes transparency for standard execution, the Scheduled implementation (DelegatingSecurityContextScheduledExecutorService) should arguably provide a mechanism to trap/log exceptions or ensuring that the security wrapper doesn't inadvertently contribute to the "silent death" of scheduled tasks.

At a minimum, documentation should warn that wrapped scheduled tasks must handle all exceptions internally.

Sample

import org.springframework.security.concurrent.DelegatingSecurityContextScheduledExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class SecuritySchedulerBug {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService delegate = Executors.newScheduledThreadPool(1);
        ScheduledExecutorService securityExecutor = new DelegatingSecurityContextScheduledExecutorService(delegate);

        System.out.println("Starting task...");

        securityExecutor.scheduleAtFixedRate(() -> {
            System.out.println("Executing task logic...");
            // Simulate a business logic error
            throw new RuntimeException("Transient Error");
        }, 0, 1, TimeUnit.SECONDS);

        Thread.sleep(5000);
        // Result: Task prints "Executing..." ONCE, then silence.
        // The schedule is dead.
    }
}

Start with DelegatingSecurityContextScheduledExecutorService.scheduleAtFixedRate and scheduleWithFixedDelay, then inspect DelegatingSecurityContextRunnable.run() and the ScheduledExecutorService contract. Reproduce the one-run suppression described in the issue and clarify whether the intended outcome is changed exception handling or a documentation warning; completion should include the chosen behavior and corresponding verification.