### Elasticsearch Version

8.9.0

### Installed Plugins

_No response_

### Java Version

_bundled_

### OS Version

all

### Problem Description

In https://github.com/elastic/elasticsearch/pull/96953 we added support for a much more memory efficient algorithm that relies on the time-ordering and grouping provided by the time-series aggregation in TSDB. However, this work only covered the data nodes, and the reduce phase in the coordinating nodes that merges geo_lines does not take this into account, leading to unexpected truncation of long geo_lines.

### Steps to Reproduce

Easiest to reproduce by setting the shard size small, loading very long geolines that will be composed of many data points over many shards, and then setting the geo_line aggregation size to a small size. The final lines will not include the two end points as they should, but be truncated.

### Logs (if relevant)

_No response_
x-pack/plugin/spatial/src/main/java/org/elasticsearch/xpack/spatial/search/aggregations/TimeSeriesGeoLineBuckets.java
import org.elasticsearch.search.aggregations.AggregationExecutionException;
import org.elasticsearch.search.aggregations.InternalAggregation;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.xpack.spatial.search.aggregations.support.GeoLineMultiValuesSource;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Supplier;
import static org.elasticsearch.xpack.spatial.search.aggregations.GeoLineAggregationBuilder.SORT_FIELD;
/**
 * Time-series aware geo_line aggregation relies on TSID and time-ordered data.
 * It does no sorting, and is therefor also able to maintain a single collector of fixed memory size,
 * and re-use this over and over for each bucket collected. The total memory used will be the max bucket size
 * multiplied by the memory cost of the internal SimplifiablePoint class, and the memory required by the underlying
 * geometry simplifier to maintain two collections of this data, one array pre-sized to the max bucket size and ordered
 * by the native time-series order (timestamp descending), and another PriorityQueue ordered by increasing cost/consequence
 * of removing a point from the collection (we remove points that have the least impact on the resulting geo_line).
 * <p>
 * Whenever the bucket id changes, the simplifier memory is copied into a new InternalGeoLine aggregation object
 * and the memory re-used for the next bucket. The last bucket is compied into InternalGeoLine in the doPostCollection
 */
class TimeSeriesGeoLineBuckets implements Releasable {
    private static final long NO_BUCKET = -1;
    private final GeoLineMultiValuesSource valuesSources;
    private final int bucketSize;
    private final Supplier<InternalGeoLine> geoLineBuilder;
    private long currentBucket;
    private final Simplifier simplifier;
    private final HashMap<Long, InternalAggregation> geoLines = new HashMap<>();