Vectors only support `f32` - should also support `f64`

I noticed that the vectors only support f32 floats:

https://github.com/qdrant/rust-client/blob/cd7ee0f5946bdf4d5c49de438230f8f9d337a6fc/src/qdrant.rs#L2037-L2042

and I ran into an issue attempting to load PointStructs that are of Vec<f64> (using embeddings generated from an ollama rust client.

/// An embeddings generation response from Ollama.
#[derive(Debug, Deserialize, Clone)]
pub struct GenerateEmbeddingsResponse {
    #[serde(rename = "embedding")]
    #[allow(dead_code)]
    pub embeddings: Vec<f64>,
}

https://github.com/pepperoni21/ollama-rs/blob/f38634d33edd2ccdb440816aa866e5614a8a1983/src/generation/embeddings.rs#L54-L60

Trying to use this vec f64 results in:

error[E0277]: the trait bound `qdrant_client::qdrant::Vectors: From<Vec<f64>>` is not satisfied
    --> src/main.rs:99:42
     |
99   |     let point = vec![PointStruct::new(0, embedding_resp.embeddings, payload)];
     |                      ----------------    ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<Vec<f64>>` is not implemented for `qdrant_client::qdrant::Vectors`
     |                      |
     |                      required by a bound introduced by this call
     |
     = help: the following other types implement trait `From<T>`:
               <qdrant_client::qdrant::Vectors as From<HashMap<std::string::String, qdrant_client::qdrant::Vector>>>
               <qdrant_client::qdrant::Vectors as From<HashMap<std::string::String, Vec<f32>>>>
               <qdrant_client::qdrant::Vectors as From<HashMap<std::string::String, Vec<(u32, f32)>>>>
               <qdrant_client::qdrant::Vectors as From<HashMap<std::string::String, &[(u32, f32)]>>>
               <qdrant_client::qdrant::Vectors as From<Vec<f32>>>
     = note: required for `Vec<f64>` to implement `Into<qdrant_client::qdrant::Vectors>`
note: required by a bound in `client::<impl qdrant_client::prelude::PointStruct>::new`
    --> /home/jmcb/.cargo/registry/src/index.crates.io-6f17d22bba15001f/qdrant-client-1.8.0/src/client.rs:1927:54
     |
1927 |     pub fn new(id: impl Into<PointId>, vectors: impl Into<Vectors>, payload: Payload) -> Self {
     |                                                      ^^^^^^^^^^^^^ required by this bound in `client::<impl PointStruct>::new`

For more information about this error, try `rustc --explain E0277`.
warning: `nvim-llama-qdrant-ctl` (bin "nvim-llama-qdrant-ctl") generated 1 warning
error: could not compile `nvim-llama-qdrant-ctl` (bin "nvim-llama-qdrant-ctl") due to 1 previous error; 1 warning emitted

Steps to reproduce

1. Bootstrap qdrant client, collection, etc.

let qdrant_client = QdrantClient::from_url("http://localhost:6334").build()?;
let collection_name = "test";

qdrant_client
    .create_collection(&CreateCollection {
        collection_name: collection_name.into(),
        vectors_config: Some(VectorsConfig {
            config: Some(Config::Params(VectorParams {
                size:  384, // size of the all-minilm embeddings
                distance: Distance::Cosine.into(),
                ..Default::default()
            })),
        }),
        ..Default::default()
    })
    .await?;

2. Bootstrap olllama client:

let ollama = Ollama::default();
let ollama = Ollama::new("http://localhost".to_string(), 11434);

3. Generate an embedding using the ollama client - this is a Vec<f64>

let embedding_model = "all-minilm".to_string();
let embedding_prompt = "Woof woof, bark bark".to_string();
let embedding_resp = ollama
    .generate_embeddings(embedding_model, embedding_prompt, None)
    .await
    .unwrap();

4. Attempt to use it in a PointStruct and notice error.

let payload: Payload = json!(
    {
        "test": "this is a test",
    }
)
    .try_into()
    .unwrap();

let point = vec![PointStruct::new(0, embedding_resp.embeddings, payload)];
client
    .upsert_points_blocking(collection_name, None, point, None)
    .await?;

Start in src/qdrant.rs around lines 2037-2042, where vector conversions are defined, and trace the conversion required by PointStruct::new. Reproduce the compiler error with a Vec embedding from the shown Ollama flow, then verify that Vec is accepted without breaking existing vector conversions.