let foo = "...";
    let foo = parse(foo);
    let foo = escaped(foo);
    ...
    doSomethingWith(foo);

I don't see how this is helpful for avoiding the bug described. The most common bug with this type of code is mistaking which form "foo" represents at a given line of code, or that form changing as the code evolves. For example, if one programmer writes

    let foo = "...";
    let foo = parse(foo);
    ...
    doBarWithFoo(foo);

and another programmer comes along, doesn't notice the call to doBarWithFoo, and needs an escaped version of foo:

    let foo = "...";
    let foo = parse(foo);
    ...
    let foo = escaped(foo);
    doBazWithFoo(foo);
    ...
    doBarWithFoo(foo); // This still looks correct in isolation

This is a classic problem with mutable variables that frequently causes hard-to-spot bugs. Whereas if each form has a distinct meaningful name, this change wouldn't introduce a bug, and if somehow a bug were introduced, good names will make it possible to spot even considering the line in isolation:

    doBarWithFoo(fooEscaped);  // Hey!  The input to doBarWithFoo shouldn't be escaped!

If the only useful form of foo is the final one, then you can avoid having accessible names for the invalid intermediate forms like this:

    let foo = escaped(parsed("..."));

Or like this for more complicated logic (I'm not a Rust programmer (yet) so this may not be the right syntax):

    let foo = {
        // Complicated logic
        finalForm;
    };

I feel like if I ever write a lot of code in Rust I'll find a linter rule that warns about shadowing variables and use it religiously. But maybe I'm missing a use case where it's crucial.