I don't think they are talking about memory management here, but simple API design.

In C++ you can write:

    template <typename Animal>
    void roar(Animal animal) { ... }

and call it like this:

    roar(airplane); // How do Airplanes roar?

You can try to fix that with an "Animal" concept, but it turns out that if someone adds a roar method to a Vehicle, you can still:

   roar(truck); // Trucks can roar... but roar expected Animal

In Rust, these things just cannot happen. If you write:

    fn roar(animal: impl Animal); 

then trying to call it with anything that's not an animal will fail to compile.

That's a good thing, but maybe somebody did wanted to call roar with a truck, and now you have to invest time into more precisely thinking which types should roar actually take, which types constraints make sense defining, how you categorize types, etc.

In Rust thinking about these things costs time. In C++ it also costs time, usually more than Rust, because you have to go way out of your way to prevent mistakes like the above. In Go you don't have to think about these issues at all because the language does not allow you to do most of this (except for interfaces, but that's another story).