### CI Link

https://gradle-enterprise.elastic.co/s/gcyi7azxnlpck/tests/:x-pack:plugin:autoscaling:test/org.elasticsearch.xpack.autoscaling.capacity.AutoscalingDeciderResultsTests/testRequiredCapacity

### Repro line

`./gradlew ':x-pack:plugin:autoscaling:test' --tests "org.elasticsearch.xpack.autoscaling.capacity.AutoscalingDeciderResultsTests.testRequiredCapacity" -Dtests.seed=2E2DFCE718729D4D -Dtests.locale=en-PH -Dtests.timezone=AST -Druntime.java=17`

### Does it reproduce?

Yes

### Applicable branches

main

### Failure history

https://gradle-enterprise.elastic.co/scans/tests?search.timeZoneId=Europe/Berlin&tests.container=org.elasticsearch.xpack.autoscaling.capacity.AutoscalingDeciderResultsTests&tests.test=testRequiredCapacity

### Failure excerpt

```
java.lang.IllegalArgumentException: processors must be a non-negative number; provided [0.0]
        at __randomizedtesting.SeedInfo.seed([2E2DFCE718729D4D:F14848089DDDD218]:0)
        at org.elasticsearch.common.unit.Processors.of(Processors.java:58)
        at org.elasticsearch.xpack.autoscaling.capacity.AutoscalingCapacity$Builder.total(AutoscalingCapacity.java:288)
        at org.elasticsearch.xpack.autoscaling.capacity.AutoscalingDeciderResultsTests.randomCapacity(AutoscalingDeciderResultsTests.java:161)
        at org.elasticsearch.xpack.autoscaling.capacity.AutoscalingDeciderResultsTests.lambda$testRequiredCapacity$1(AutoscalingDeciderResultsTests.java:65)
        at java.base/java.util.stream.IntPipeline$1$1.accept(IntPipeline.java:180)
        at java.base/java.util.stream.Streams$RangeIntSpliterator.forEachRemaining(Streams.java:104)
        at java.base/java.util.Spliterator$OfInt.forEachRemaining(Spliterator.java:711)
        at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
        at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
```
x-pack/plugin/autoscaling/src/test/java/org/elasticsearch/xpack/autoscaling/capacity/AutoscalingDeciderResultsTests.java
Map<String, Object> map = toMap(results);
        boolean hasRequiredCapacity = results.requiredCapacity() != null;
        Set<String> roots = hasRequiredCapacity
            ? Set.of("current_capacity", "current_nodes", "deciders", "required_capacity")
            : Set.of("current_capacity", "current_nodes", "deciders");
        assertThat(map.keySet(), equalTo(roots));
        assertThat(map.get("current_nodes"), instanceOf(List.class));
        List<?> expectedNodes = results.currentNodes().stream().map(dn -> Map.of("name", dn.getName())).collect(Collectors.toList());
        assertThat(map.get("current_nodes"), equalTo(expectedNodes));
        if (hasRequiredCapacity) {
            assertThat(map.get("required_capacity"), equalTo(toMap(results.requiredCapacity())));
        }
        assertThat(map.get("current_capacity"), equalTo(toMap(results.currentCapacity())));
        assertThat(
            map.get("deciders"),
            equalTo(results.results().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> toMap(e.getValue()))))
        );
    }
    public Map<String, Object> toMap(ToXContent tox) {
        try (XContentBuilder builder = XContentFactory.jsonBuilder()) {
            if (tox.isFragment()) {
                builder.startObject();
            }
            tox.toXContent(builder, null);
            if (tox.isFragment()) {
                builder.endObject();
            }
            try (
                XContentParser parser = XContentType.JSON.xContent()
                    .createParser(XContentParserConfiguration.EMPTY, BytesReference.bytes(builder).streamInput())