Off by one: return type on associated function/method wraps at exactly `max_width`

The problem occurs in the following code, note that the longest line is exactly 100 columns:

pub trait Manager {
    fn attach_device(&self, seat_id: &str, sysfs_path: &str, interactive: bool) -> zbus::Result<()>;
}

If this is formatted with the 2021 edition, you get the following:

pub trait Manager {
    fn attach_device(&self, seat_id: &str, sysfs_path: &str, interactive: bool)
        -> zbus::Result<()>;
}

This isn't technically correct, since it shouldn't be broken at all, but at least the arrow is indented properly to make the association to the function clear.

With the 2024 edition, it formats like this:

pub trait Manager {
    fn attach_device(&self, seat_id: &str, sysfs_path: &str, interactive: bool)
    -> zbus::Result<()>;
}

So still breaks the line that doesn't need to be broken, but even worse than 2021 edition.

If the line is a single character longer, it's not broken at all:

pub trait Manager {
    fn attach_device(&self, seat_id: &str, sysfs_path: &str, interactiv: bool) -> zbus::Result<()>;
}

If it is one character longer, the arguments are broken vertically:

pub trait Manager {
    fn attach_device(
        &self,
        seat_id: &str,
        sysfs_path: &str,
        interactivee: bool,
    ) -> zbus::Result<()>;
}

Surely this can't be intentional? It seems like some sort of off-by-one error to me. I'd honestly be happier with having it broken apart vertically than that ugly 2024 formatting, even though it shouldn't require formatting at all.

No source file or test is named. Reproduce the supplied Rust examples at max_width 100 in the 2021 and 2024 editions, then trace the return-type break decision; done when the boundary no longer produces the incorrect 2024 indentation and regression coverage captures the examples.