If there are only these three possible types

This is not correct. Fn, FnMut, and FnOnce are not types, they are traits. In fact, they cannot be just types.

While any ordinary fn you define can be represented as a simple pointer, closures are a completely different thing. They can capture their environment, which in practice means that they can use the variables defined near them. This also means that they need to store these variables somewhere, as you can’t really know when exactly the closure will be executed. Every closure might want to capture different types of variables, all having different sizes, so there can’t be a one-size-fits-all type that could contain any sort of “context” that you might possibly use. Hence, through the compiler magic, an unnamable type is created, which you can confirm with a simple code snippet:

let mut x = 5;
let f = || {
    x += 1;
};

println!("size_of({}) = {}", std::any::type_name_of_val(&f), std::mem::size_of_val(&f));

This prints:

size_of(playground::main::{{closure}}) = 8

Under the hood, what happens in the above code is something close to this:

let mut x = 5;
struct Closure<'a> {
    // closure context
    x: &'a mut i32,
}
impl FnOnce<()> for Closure<'_> {
    type Output = ();
    extern "rust-call" fn call_once(self, _args: ()) -> Self::Output {
        // closure body
        *self.x += 1;
    }
}
let f = Closure { x: &mut x };

// now it can be called:
f();

The closure object in this case must contain a mutable reference to the variable it modifies, so the closure type is 8 bytes long (on a 64-bit platform). You might want to experiment a little with different closures capturing different things and notice that the closure type size directly depends on the variables it captures.

See also: How do Rust closures work and how does it execute a closure?

That is because each individual function or closure has a separate and unique type.

Fn, FnMut and FnOnce are traits, not types.

Take the following two examples:

fn add(l: i32, r: i32) -> i32 {
    l + r
}

fn subtract(l: i32, r: i32) -> i32 {
    l - r
}

These two functions have the exact same signature, therefore they implement the exact same function traits.

However, the type of these functions is not the same. Each individual function is given its own unique, unnamed type.

This is why you have to use them through those traits.