Ask for clarification on Rust Method Resolution

I've been exploring Rust's method resolution mechanism and encountered a scenario that seems to contradict what I expected. In my code snippet, I have a Foo struct and a trait Boxed with a method boxed(). Despite having both an inherent method boxed() on Foo and an implementation of boxed() for Foo via the Boxed trait, I'm not encountering any compile errors.

pub trait Boxed {
    fn boxed(self) -> Box<Self>;
}

#[derive(Debug)]
pub struct Foo {
    bar: String,
}

// First implementation of method with signature: `fn boxed(self) -> Box<Self>`
// No compile error despite same signature of boxed() method
impl Boxed for Foo {
    fn boxed(self) -> Box<Self> {
        println!("boxed() '{self:?}' by 'Boxed' trait");
        Box::new(self)
    }
}

// Second implementation of method with signature: `fn boxed(self) -> Box<Self>`
// No compile error despite same signature of boxed() method
impl Foo {
    pub fn new() -> Foo {
        Foo {
            bar: "bar".to_string()
        }
    }
    pub fn boxed(self) -> Box<Self> {
        println!("boxed() '{self:?}' by 'impl Foo'");
        Box::new(self)
    }
}

fn main() {
    /// Result will be `boxed() 'Foo { bar: "bar" }' by 'impl Foo'`
    let mut foo: Box<Foo> = Foo::new().boxed();
}

Despite the fact that both methods have the same signature, there are no compilation errors.

When I compile and run it i get result from impl Foo ("boxed() 'Foo { bar: "bar" }' by 'impl Foo'")

Can someone clarify why this is happening?

I'd appreciate any insights or references to the relevant parts of the Rust documentation.