If each plugin had a single handler then all the work of remembering which parts of the plugin had been completed and which had not would have to be implemented inside every individual plugin's single error handler,

Where'd you get that from? I didn't suggest removing any calls to register. I suggested you pass an object as argument.

do_a();
my::Error::register(\&undo_a, ARGS);
if ($do_c) {
    do_c();
    my::Error::register(\&undo_c, ARGS);
}
do_b();
my::Error::register(\&undo_b, ARGS);
[download]

to

do_a();
register_err_handler(a => ARGS);
if ($do_c) {
    do_c();
    register_err_handler(c => ARGS);
}
do_b();
register_err_handler(b => ARGS);

sub register_err_handler {
    my::Error::register( my::Plugin::ErrorHandler_->new(@_) );
}
[download]

The handler is trivial:

package my::Plugin::ErrorHandler;

sub new {
    my $class   = shift;
    my $handler = shift;
    return bless({ handler => $handler, args => [ @_ ] }, $class);
}

my %dispatch = (
    a => \&my::Plugin::undo_a,
    b => \&my::Plugin::undo_b,
    c => \&my::Plugin::undo_c,
);

sub handle_error {
    my ($self) = @_;
    $dispatch{ $self->{handler} }->(@{ $self->{args} })
}
[download]

This gives you a lot of flexibility (including the ability to serialise undo data) without messing with magic.

That said, given the details that recently came to light, yes, you might as well do

do_a();
my::Error::register(undo_a => ARGS);
if ($do_c) {
    do_c();
    my::Error::register(undo_c => ARGS);
}
do_b();
my::Error::register(undo_b => ARGS);
[download]

You can always pass an object as one of the args if if custom serialisation is needed.