What mistake with the compiler made that can result in the lifetime being extended from a small one?

I mean it changes how the function item is defined, and that has an impact on what how the function item has to implement traits, what it can be cast to, and so on. It's like... the function item itself is less general.

But it is the case that explicit bounds are treated as less general than implicit bounds. Let's consider a case where there's no substantial difference in the implementing types. Here's an example where the implementations are semantically the same, but the explicit version is less general as far as the compiler is concerned.

trait Foo<T> {}

struct Implicit;
struct Explicit;

impl<'a, T> Foo<&'a T> for Implicit {}
impl<'a, T: 'a> Foo<&'a T> for Explicit {}

fn witness<'s, F: for<'a> Foo<&'a &'s str>>() {}

fn check<'s>() {
    // compiles
    witness::<'s, Implicit>();
    // fails
    witness::<'s, Explicit>();
}

Or another one, this actually came up indirectly in another thread today.

These examples demonstrate that it's not just function item types being different that causes problems, it's the presence of explicit bounds in some cases. The compiler does treat them differently.