BEGIN {

    package Before;
    my (%looper);
    use overload '&{}' => sub {
        my ($f) = @_;
        print "Stuff before \n";
        return $looper{ overload::StrVal($f) };
    };

    sub new {
        my ( $package, $sub ) = @_;
        my $self = bless sub { }, $package;
        my $fs = overload::StrVal($self);
        $looper{$fs} = $sub;
        use Scalar::Util();
        Scalar::Util::weaken( $looper{$fs} );
        return $self;
    }
}

package main;
{
    my $fx = sub { print "I am a side effect\n" };
    my $now = Before->new($fx);
    $now->();
    warn "fx => $fx ";
    warn "now => ", overload::StrVal $now ;
    bless $fx, 'Before';
    warn "fx => ", overload::StrVal $fx;
    $fx->();
}
__END__
Stuff before
I am a side effect
fx => CODE(0x18513ac)  at - line 27.
now => Before=CODE(0x18304d0) at - line 28.
fx => Before=CODE(0x18513ac) at - line 30.
Stuff before
Overloaded dereference did not return a reference at - line 31.
[download]

This is an interesting variant of ELISHEVA's reply below, and it specifically addresses my use case in Re^2: Overloading without infinite descent. I do appreciate the other ways of thinking about this problem, but my question is less about “How else can I do this?” and more specifically about “Is there a way to ‘undo’ overloading”?

(The very act of re-phrasing the problem that way made me wonder if no overload might do it, but it doesn't.)

Maybe by temporarily re-bless-ing?

Yes, don't use perl :) use XS.