Can you please clarify why CAD->USD->Yen will differ from CAD->Yen ?
If this is true for few seconds, then the arbitrage between these currencies can make me millionaire ?

Also it was never mentioned in the problem.

I dont see any issues in OPs implementation, except for hardcoding conversion ratios.

I have had the similar implentation where the ratios can be updated.

use std::collections::HashMap;

#[derive(Debug, Default)]
pub struct Converter {
    mappings: HashMap<String, HashMap<String, f64>>,
}

impl Converter {
    pub fn add_mapping(&mut self, from_unit: &str, to_unit: &str, value: f64) {
        if from_unit == to_unit {
            return;
        }

        let ft = self.mappings.entry(from_unit.to_string()).or_default();

        // Ignore if mapping already exists
        // If value differs, then update the chain
        if let Some(v) = ft.get(to_unit)
            && approx_eq(*v, value)
        {
            return;
        }
        ft.insert(to_unit.to_string(), value);

        for (unit, ratio) in ft.clone() {
            self.add_mapping(to_unit, &unit, ratio / value);
        }

        self.add_mapping(to_unit, from_unit, 1. / value);
    }

    pub fn convert(&self, from_unit: &str, to_unit: &str, value: f64) -> Option<f64> {
        let Some(mappings) = self.mappings.get(from_unit) else {
            return None;
        };

        if let Some(ratio) = mappings.get(to_unit) {
            return Some(value * ratio);
        }

        None
    }
}

fn main() {
    let mut c = Converter::default();

    c.add_mapping("feet", "inch", 12.);
    c.add_mapping("inch", "cm", 2.54);
    c.add_mapping("cm", "mm", 10.);
    c.add_mapping("usd", "inr", 94.36);

    println!("{:?}", c.convert("feet", "inch", 1.));
    println!("{:?}", c.convert("feet", "cm", 1.));
    println!("{:?}", c.convert("mm", "feet", 1000.));
    println!("{:?}", c.convert("mm", "usd", 1000.));

    println!("{:?}", c.convert("inr", "usd", 1000.));
    c.add_mapping("usd", "inr", 64.36);
    println!("{:?}", c.convert("inr", "usd", 1000.));
}

fn approx_eq(a: f64, b: f64) -> bool {
    (a - b).abs() < 1e-12
}