### Description

When storing vectors outside of Lucene's HNSW structure, we take advantage of binary fields.

Currently, we store floats with big endianness. But, if we would instead store them little endian, we get a nice reduction in decoding latency when reading the bytes again for later comparisons.

Here are some benchmark results. Note how Little Endian (LE) and `decodeFloatBufferBulk` is twice as fast as `decodeByteBufferDirectRead` (LE or BE)
```
Benchmark                                                          (byteOrderString)  (floatArraySizes)  Mode  Cnt          Score         Error  Units
ByteBufferFloatDecodeLatencyBenchmark.decodeByteBufferDirectRead                  LE               2048  avgt    5   68325739.360 ±  465582.836  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeByteBufferDirectRead                  BE               2048  avgt    5   74776992.386 ±  823331.552  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeByteBufferIteration                   LE               2048  avgt    5  117525705.067 ± 1458961.093  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeByteBufferIteration                   BE               2048  avgt    5  123655802.233 ± 4235944.321  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeFloatBufferBulk                       LE               2048  avgt    5   34669449.786 ±  160521.025  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeFloatBufferBulk                       BE               2048  avgt    5  110294944.298 ± 2603621.064  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeFloatBufferDirectRead                 LE               2048  avgt    5   68806487.680 ± 3232644.206  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeFloatBufferDirectRead                 BE               2048  avgt    5   69113588.627 ±  206808.093  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeFloatBufferIteration                  LE               2048  avgt    5  106361490.140 ± 1621399.226  ns/op
ByteBufferFloatDecodeLatencyBenchmark.decodeFloatBufferIteration                  BE               2048  avgt    5  110686951.689 ± 3408080.477  ns/op
```

To make this change, however, requires knowing the version of the index storing the field value. 
server/src/test/java/org/elasticsearch/index/mapper/vectors/DenseVectorFieldMapperTests.java
vector[i] = randomByte();
        }
        ParsedDocument doc1 = mapper.parse(source(b -> b.array("field", vector)));
        List<IndexableField> fields = doc1.rootDoc().getFields("field");
        assertEquals(1, fields.size());
        assertThat(fields.get(0), instanceOf(XKnnByteVectorField.class));
        XKnnByteVectorField vectorField = (XKnnByteVectorField) fields.get(0);
        assertEquals(dims, vectorField.fieldType().vectorDimension());
        assertEquals(VectorEncoding.BYTE, vectorField.fieldType().vectorEncoding());
        assertEquals(similarity.function, vectorField.fieldType().vectorSimilarityFunction());
        assertArrayEquals("Parsed vector is not equal to original.", vector, vectorField.vectorValue());
    }
    @Override
    protected void assertFetchMany(MapperService mapperService, String field, Object value, String format, int count) throws IOException {
        assumeFalse("Dense vectors currently don't support multiple values in the same field", false);
    }
    /**
     * Dense vectors don't support doc values or string representation (for doc value parser/fetching).
     * We may eventually support that, but until then, we only verify that the parsing and fields fetching matches the provided value object
     */
    @Override
    protected void assertFetch(MapperService mapperService, String field, Object value, String format) throws IOException {
        MappedFieldType ft = mapperService.fieldType(field);
        MappedFieldType.FielddataOperation fdt = MappedFieldType.FielddataOperation.SEARCH;
        SourceToParse source = source(b -> b.field(ft.name(), value));
        SearchExecutionContext searchExecutionContext = mock(SearchExecutionContext.class);
        when(searchExecutionContext.isSourceEnabled()).thenReturn(true);
        when(searchExecutionContext.sourcePath(field)).thenReturn(Set.of(field));
        when(searchExecutionContext.getForField(ft, fdt)).thenAnswer(inv -> fieldDataLookup(mapperService).apply(ft, () -> {
            throw new UnsupportedOperationException();