When transform isn't able to detect changes it logs and audits the following message as warning:

`[${transform_id}] failed to detect changes for transform. Skipping update till next check.`

On a broken cluster this causes a flood of log messages as this gets logged for every failure. The failure happens based on `frequency`. Apart from the log spam this check isn't properly integrated into retry and failure handlers. The later would prevent the spam. The failure handler lets the transform retry based on exponential back-off. A transform that isn't executed as `unattended` should fail after the configured number of retries (if the number of retries is configured as -1 it should retry forever).

The code in question can be found in `sourceHasChanged` (called by `onStart`) in `TransformIndexer`

Todo:

 - [ ] create a failure test case that simulates the error (see details below)
 - [x] don't suppress the failure in `sourceHasChanged`, but let the error pass and be handled in `TransformFailureHandler`

Details:

The failure:

```
Caused by: org.elasticsearch.action.search.SearchPhaseExecutionException: Search rejected due to missing shards [[...][0], [...][0]]. Consider using `allow_partial_search_results` setting to bypass this error.
    at org.elasticsearch.action.search.AbstractSearchAsyncAction.run(AbstractSearchAsyncAction.java:245) ~[elasticsearch-8.5.1.jar:?]
```
x-pack/plugin/transform/src/main/java/org/elasticsearch/xpack/transform/transforms/TransformIndexer.java
case APPLY_RESULTS:
                return processBuckets(searchResponse);
            case IDENTIFY_CHANGES:
                return processChangedBuckets(searchResponse);
            default:
                
                logger.warn("[{}] Encountered unexpected run state [{}]", getJobId(), runState);
                throw new IllegalStateException("Transform indexer job encountered an illegal state [" + runState + "]");
        }
    }
    @Override
    public boolean maybeTriggerAsyncJob(long now) {
        
        if (context.getTaskState() == TransformTaskState.FAILED) {
            logger.debug("[{}] schedule was triggered for transform but task is failed. Ignoring trigger.", getJobId());
            return false;
        }
        synchronized (context) {
            
            IndexerState indexerState = getState();
            if (IndexerState.INDEXING.equals(indexerState) || IndexerState.STOPPING.equals(indexerState)) {
                logger.debug("[{}] indexer for transform has state [{}]. Ignoring trigger.", getJobId(), indexerState);
                return false;
            }
            /*
             * ignore if indexer thread is shutting down (after finishing a checkpoint)
             * shutting down means:
             *  - indexer has finished a checkpoint and called onFinish
             *  - indexer state has changed from indexing to started
             *  - state persistence has been called but has _not_ returned yet