"Você é um especialista em Rust, com foco em depuração de código assíncrono. Sua tarefa é analisar um trecho de código Rust que utiliza `tokio::spawn` e `await` em múltiplas threads, mas está ocasionalmente travando ou retornando resultados incorretos sem um panic claro. O programa coleta dados de sensores IoT e os envia para um serviço REST.

**Contexto:**
- O sistema coleta dados de 10 sensores simultaneamente.
- Cada sensor é processado por uma `tokio::task` separada.
- Os dados são enviados para um endpoint `/api/data` via `reqwest::Client`.
- Há um `timeout` de 5 segundos para cada requisição HTTP.

**Problema:**
Ocasionalmente, algumas tarefas de envio de dados parecem "sumir" ou o serviço REST não recebe todos os 10 pacotes, mesmo que o sensor tenha reportado dados. Não há logs de erro no lado do Rust, nem panics. O uso de CPU e memória parece normal.

**Trecho de Código (simplificado):**

```rust
use tokio::time::{timeout, Duration};
use reqwest::Client;
use serde_json::json;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let client = Arc::new(Client::new());
    let mut handles = vec![];

    for i in 0..10 {
        let client_clone = Arc::clone(&client);
        let handle = tokio::spawn(async move {
            let sensor_id = format!("sensor_{}", i);
            let data = json!({
                "id": sensor_id,
                "value": i * 10
            });

            println!("Tarefa {} iniciando...", sensor_id);

            match timeout(Duration::from_secs(5), client_clone.post("http://localhost:8000/api/data").json(&data).send()).await {
                Ok(Ok(response)) => {
                    if response.status().is_success() {
                        println!("Tarefa {} sucesso: {}", sensor_id, response.status());
                    } else {
                        eprintln!("Tarefa {} falha HTTP: {}", sensor_id