### Elasticsearch Version

8.6.1, also tested on 8.5.3

### Installed Plugins

_No response_

### Java Version

_bundled_

### OS Version

Ubuntu 20.04.5 LTS

### Problem Description

Attempting to update force_merge_index for searchable snapshot actions within phases inside an ILM policy appear to ignore the update.
Version of the policy remains the same if checked after.
A workaround is changing at least one other element of the policy then the changes are accepted and the policy version is updated.

### Steps to Reproduce

```
# test create policy 
PUT /_ilm/policy/test
{
  "policy": {
    "phases": {
      "cold": {
        "min_age": "5d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": true
          },
          "set_priority": {
            "priority": 0
          }
        }
      },
      "warm": {
        "min_age": "3d",
        "actions": {
          "forcemerge": {
            "max_num_segments": 1
          },
          "set_priority": {
            "priority": 50
          }
        }
      },
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_primary_shard_size": "50gb",
            "max_age": "30d"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "frozen": {
        "min_age": "25d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": true
          }
        }
      }
    }
  }
}


# check policy
GET /_ilm/policy/test

# update policy to have force merge set to false for cold and frozen phases
PUT /_ilm/policy/test
{
  "policy": {
    "phases": {
      "cold": {
        "min_age": "5d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": false
          },
          "set_priority": {
            "priority": 0
          }
        }
      },
      "warm": {
        "min_age": "3d",
        "actions": {
          "forcemerge": {
            "max_num_segments": 1
          },
          "set_priority": {
            "priority": 50
          }
        }
      },
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_primary_shard_size": "50gb",
            "max_age": "30d"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "frozen": {
        "min_age": "25d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": false
          }
        }
      }
    }
  }
}

# check policy - version is still 1 and no changes have taken affect.
GET /_ilm/policy/test


# update policy to have force merge set to false for cold and frozen phases, but also change at least 1 other element of the policy, in this case one of the order values.
PUT /_ilm/policy/test
{
  "policy": {
    "phases": {
      "cold": {
        "min_age": "5d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": false
          },
          "set_priority": {
            "priority": 0
          }
        }
      },
      "warm": {
        "min_age": "3d",
        "actions": {
          "forcemerge": {
            "max_num_segments": 1
          },
          "set_priority": {
            "priority": 51
          }
        }
      },
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_primary_shard_size": "50gb",
            "max_age": "30d"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "frozen": {
        "min_age": "25d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": false
          }
        }
      }
    }
  }
}

# check policy - version is 2 and changes have taken effect.
GET /_ilm/policy/test

# you could also reset the priority back to what it was if needed
PUT /_ilm/policy/test
{
  "policy": {
    "phases": {
      "cold": {
        "min_age": "5d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": false
          },
          "set_priority": {
            "priority": 0
          }
        }
      },
      "warm": {
        "min_age": "3d",
        "actions": {
          "forcemerge": {
            "max_num_segments": 1
          },
          "set_priority": {
            "priority": 50
          }
        }
      },
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_primary_shard_size": "50gb",
            "max_age": "30d"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "frozen": {
        "min_age": "25d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "found-snapshots",
            "force_merge_index": false
          }
        }
      }
    }
  }
}

# check policy - version is 3 and changes have taken effect again.
GET /_ilm/policy/test
```

### Logs (if relevant)

_No response_
x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/ilm/SearchableSnapshotActionTests.java
assertThat(steps.get(1).getKey(), is(expectedSteps.get(1)));
        assertThat(steps.get(2).getKey(), is(expectedSteps.get(2)));
        assertThat(steps.get(3).getKey(), is(expectedSteps.get(3)));
        assertThat(steps.get(4).getKey(), is(expectedSteps.get(4)));
        assertThat(steps.get(5).getKey(), is(expectedSteps.get(5)));
        assertThat(steps.get(6).getKey(), is(expectedSteps.get(6)));
        assertThat(steps.get(7).getKey(), is(expectedSteps.get(7)));
        assertThat(steps.get(8).getKey(), is(expectedSteps.get(8)));
        assertThat(steps.get(9).getKey(), is(expectedSteps.get(9)));
        assertThat(steps.get(10).getKey(), is(expectedSteps.get(10)));
        assertThat(steps.get(11).getKey(), is(expectedSteps.get(11)));
        assertThat(steps.get(12).getKey(), is(expectedSteps.get(12)));
        assertThat(steps.get(13).getKey(), is(expectedSteps.get(13)));
        assertThat(steps.get(14).getKey(), is(expectedSteps.get(14)));
        assertThat(steps.get(15).getKey(), is(expectedSteps.get(15)));
        if (action.isForceMergeIndex()) {
            assertThat(steps.get(16).getKey(), is(expectedSteps.get(16)));
            assertThat(steps.get(17).getKey(), is(expectedSteps.get(17)));
            CreateSnapshotStep createSnapshotStep = (CreateSnapshotStep) steps.get(8);
            assertThat(createSnapshotStep.getNextKeyOnIncomplete(), is(expectedSteps.get(7)));
            validateWaitForDataTierStep(phase, steps, 9, 10);
        } else {
            CreateSnapshotStep createSnapshotStep = (CreateSnapshotStep) steps.get(6);
            assertThat(createSnapshotStep.getNextKeyOnIncomplete(), is(expectedSteps.get(5)));
            validateWaitForDataTierStep(phase, steps, 7, 8);
        }
    }
    private void validateWaitForDataTierStep(String phase, List<Step> steps, int waitForDataTierStepIndex, int mountStepIndex) {
        WaitForDataTierStep waitForDataTierStep = (WaitForDataTierStep) steps.get(waitForDataTierStepIndex);
        if (phase.equals(TimeseriesLifecycleType.HOT_PHASE)) {