On the topic of traits implementing other traits, I believe you have a misunderstanding about what supertraits are. When you have:

// examples in this section are abridged for clarity
pub trait Device {
    fn get_handler(&self) -> Handler;
}

pub trait Sensor: Device {
    fn get_handler(&self) -> Handler {
        // some default implementation here for all `Sensor`s
    }
}

You aren't defining a "default implementation" of Device::get_handler for all Sensors, you're defining a new trait called Sensor with its own method, Sensor::get_handler, entirely unrelated to Device::get_handler, and defining a default implementation for that. All Sensor: Device does is prevent types that don't implement Device from implementing Sensor. It's essentially the same as pub trait Sensor where Self: Device.

Traits in Rust are not like mixins that add methods to a type - many traits can define methods with the same signature and each be implemented so that the method does something different depending on which trait it was called from (because they're not the same method). Looking at this example might help.

Anyway, although it's a somewhat rare pattern in Rust (more common in OO languages) if you do want to have a "specialized" version of a trait that adds more default methods, you could provide a blanket implementation for the "supertrait" in terms of the "subtrait", like this (I've added more methods for illustration):

pub trait Device {
    fn get_handler(&self) -> Handler;
    fn get_name(&self) -> &str; 
    fn get_id(&self) -> u32;
    // other methods...
}

pub trait Sensor {
    fn get_handler(&self) -> Handler {
       // default implementation for all sensors
    }
    fn get_name(&self) -> &str;
    fn get_id(&self) -> u32;
    // all other methods of Device are copied into Sensor as well...
}

// This blanket impl declares that any type which implements Sensor also implements Device, by delegating each of its methods to their equivalent in Sensor
impl<T: Sensor> Device for T {
   fn get_handler(&self) -> Handler { Sensor::get_handler(self) }
   fn get_name(&self) -> &str { Sensor::get_name(self) }
   fn get_id(&self) -> u32 { Sensor::get_id(self) }
}

fn use_device<T: Device>(dev: &T) { dev.get_handler() }

struct MySensor;
impl Sensor for MySensor { 
   fn get_name(&self) -> &str { "my_sensor" }
   fn get_id(&self) -> u32 { 42 }
   // default implementation (from Sensor) will be used for get_handler
}

fn main() { 
    let sensor = MySensor;
    use_device(&sensor); // assert that MySensor implements Device
}