I only used Guard for convenience. It can easily be replaced by

package My::Guard;
use strict;
sub new {
    bless $_[1] => $_[0];
};
sub DESTROY {
    $_[0]->()
};
[download]

The full (and really pure Perl) program then becomes:

#!perl -w
package My::Guard;
use strict;
sub new {
    bless $_[1] => $_[0];
};
sub DESTROY {
    $_[0]->()
};

package main;
use strict;

sub alias {\@_};
sub localize {
    my @values = @{ +pop }; # or any other convenient method
    my $aliases=alias(@_);
    my @saved= @_;

    #warn Dumper \@saved;
    $_[$_] = $values[$_] for 0..$#values;
    My::Guard->new(sub{
        $aliases->[$_]=$saved[$_] for 0..$#saved;
    })
};

my ($a,$b)=('a','b');

print "Start\n";
print qq($a $b),"\n";

my $restore=localize($a,$b,['foo','bar']);

print "Localized\n";
print qq($a $b),"\n";
undef $restore;
print "Restored\n";
print qq($a $b), "\n";
[download]

But still, you haven't convinced me that there are problems to which Scope::Upper is a good solution.

Update: As an afterthought, for somebody who thinks they need Scope::Upper, I think you should investigate the easier and potentially less powerful methods first, like having a destructor invoke a callback. I don't consider this a rare/outlandish technique, and there are many packages implementing this, like AtExit, Aspect::Guard, Scope::Guard and ReleaseAction.

Update2: Of course, this clever idea has a big drawback. It doesn't work for arrays and hashes.

-- you haven't convinced me that there are problems to which Scope::Upper is a good solution.

Do I need to convince you?

I only need convince myself before I chose to use it (or not) in my code?

No, you don't need to convince me. So far, you haven't shown the concrete use case at hand, nor convinced me of the abstract idea that there may be a use case. You seem to want to keep your use case to yourself, but are somehow prevented from saying so. I don't know why that is the case. It just confirms to me that without a concrete use case, discussing the use of heavy machinery does not make sense, as the costs and benefits cannot be made clear.

But then again, this was mostly for my idle curiosity, and thus not really important. It allowed me to revisit funny parts of the toolshed, and provided idle amusement for a few minutes, even though the promise of learning a new code situation did not come through.