I think what's going on is that since @_ are aliases, this actually clears out the argument as well.

That would be the behaviour you'd get if local simply backed up the current value of a variable and restored it on scope exit.

As you discovered, that's not what local does. Instead, it creates a new variable, aliases the name to the new variable, and aliases the name back to the original variable on scope exit.

$ perl -e'
   use feature qw( say );
   say 0+\$x;
   { local $x; say 0+\$x; }
   say 0+\$x;
'
94031376424552
94031376229560
94031376424552
[download]

That means the fact that $_[0] is an alias for the localized variable shouldn't matter. And it normally doesn't.

$ perl -e'
   use feature qw( say );
   $x = 2;
   say 0+\$x;
   say $x;
   sub {
      local $x = 3;
      say 0+\$x;
      say $x;
      say $_[0];
   }->( $x );
   say 0+\$x;
   say $x;
'
94300947464040   Address of pre-local $x
2                Value of pre-local $x
94300947268840   Address of post-local $x
3                Value of post-local $x
2                Value of pre-local $x
94300947464040   $x is restored
2                Value of pre-local $x
[download]

But $! is magical. And more specifically, it's a proxy for a C variable. local copies the magic onto the new scalar it creates. So you end up with two variables (the $! passed as argument and the new $! created by local) which both use the same C variable for storage.

$ perl -e'
   use feature qw( say );
   $! = 2;
   say 0+\$!;
   say 0+$!;
   sub {
      local $! = 3;
      say 0+\$!;
      say 0+$!;
      say 0+$_[0];
   }->( $! );
   say 0+\$!;
   say 0+$!;
'
93839899443048   Address of pre-local $!
2                Value of pre-local $! (aka value of errno)
93839899247848   Address of post-local $!
3                Value of post-local $! (aka value of errno)
3                Value of pre-local $! (aka value of errno)
93839899443048   $! is restored
3                Value of pre-local $! (aka value of errno)
[download]

The net effect is that local $! doesn't really localize $! at all!

$? is similarly a proxy for a C variable. $@ isn't magical.