Not quite sure what you mean. Maybe like this?

package Foo {
    sub new { bless [] };
    
    sub msg {
        my $self = shift;
        printf "On my way to '%s'\n", @_;
    }
    
    sub Berlin {
        my $self = shift;
        $self->msg('Berlin');
        print "I'm in Berlin!\n";
    }
    
    sub Paris {
        my $self = shift;
        $self->msg('Paris');
        print "I'm in Paris!\n";
    }
};

my $obj = Foo->new;
$obj->Berlin();
[download]

Or maybe you mean like this?

package Foo {
    sub new { bless [] };
    
    sub msg {
        my $self = shift;
        printf "On my way to '%s'\n", @_;
    }
    
    sub Berlin {
        my $self = shift;
        print "I'm in Berlin!\n";
    }
    
    sub Paris {
        my $self = shift;
        print "I'm in Paris!\n";
    }
};

use Class::Method::Modifiers qw( install_modifier );

for my $city (qw/ Paris Berlin /)
{
    install_modifier "Foo", before => $city => sub {
        my $self = shift;
        $self->msg($city);
    };
}

my $obj = Foo->new;
$obj->Berlin();
[download]

Thank you very much. Class::Method::Modifiers does exactly what I want, but the bad thing is that you must know all the method names. I worked around this issue by using the special hash %PackageName::, but I really don't like this ugly fix. I looked briefly in the documentation of overload, but there doesn't seem to be any way to overload the method caller. Maybe, will come some day...

use 5.014;

package Foo {
    sub new { bless [] }

    use Class::Method::Modifiers qw(before);

    foreach my $method (keys %Foo::) {

        next if $method
            =~ /^(_|(?:BEGIN|new|before)\z)/;

        before $method => sub {
            my ($self) = @_;
            print "** Preparing...\n";
            push @{$self}, 'money';
            print "** Ready to continue...\n";
        };
    }

    sub Berlin {
        my $self = shift;
        print "> I'm in Berlin!\n";
    }

    sub Paris {
        my $self = shift;
        print "> I'm in Paris!\n";
    }

};

my $obj = Foo->new;
$obj->Berlin();
say "# Self contains: @{$obj}";
[download]

Sub attributes provide a fairly nice alternative...

use 5.014;

package Foo {
    sub new { bless [] }
    
    use Attribute::Handlers;
    use Class::Method::Modifiers qw(before);
    
    sub City :ATTR
    {
        my $method = substr *{$_[1]}, 1;
        before $method => sub {
            my ($self) = @_;
            print "** Preparing...\n";
            push @{$self}, 'money';
            print "** Ready to continue...\n";
        };
    }
    
    sub Berlin :City {
        my $self = shift;
        print "> I'm in Berlin!\n";
    }
    
    sub Paris :City {
        my $self = shift;
        print "> I'm in Paris!\n";
    }
};

my $obj = Foo->new;
$obj->Berlin();
say "# Self contains: @{$obj}";
[download]

use Moops; class Cow :rw { has name => (default => 'Ermintrude') }; say Cow->new->name

#!/usr/bin/perl
use warnings;
use strict;

package Foo {
    use Moo;

    sub msg {
        printf "On my way to '%s'\n", shift;
    }

    sub Berlin {
        print "I'm in Berlin!\n";
    }

    sub Paris {
        print "I'm in Paris!\n";
    }

    for my $city (qw( Berlin Paris )) {
        before $city => sub { msg($city) };
    }
};

my $obj = Foo->new;
$obj->Berlin();       # should go first in msg(), then in Berlin()
[download]

The approaches of tobyink and choroba sound like they are what you want (and they're certainly more sophisticated than my approach), but would the following be useful?

>perl -wMstrict -e
"use 5.014;
 ;;
 package Foo {
   ;;
   sub new { bless [] };
   ;;
   sub msg {
     my $self = shift;
     my ($destination) = @_;
     printf qq{On my way to '%s'. }, $destination;
     my $coderef = $self->can($destination);
     return print qq{Cannot get there. \n} unless $coderef;
     $self->$coderef($destination);
     }
   ;;
   sub Berlin { my $self = shift;  print qq{I am in $_[0]! \n};  }
   ;;
   sub Paris  { my $self = shift;  print qq{Arrived in $_[0]! \n}; }
   ;;
   }
 ;;
 my $obj = Foo->new;
 $obj->msg('Berlin');
 $obj->msg('Paris');
 $obj->msg('London');
"
On my way to 'Berlin'. I am in Berlin!
On my way to 'Paris'. Arrived in Paris!
On my way to 'London'. Cannot get there.
[download]

Update: See perlobj, perltoot, perltooc for info on can(). (Update: perltoot and perltooc exist for Perl 5.14, but have been superceded for 5.18. So you're on your own...)

As far as I am aware, the only way to do this is to have the called-class (explicitly) invoke its superclass.   (Or, in the case at bar, both the Berlin and the Paris methods would have to explicitly call msg(), and if there were more than half-a-dozen of these I’d be declaring another class.)

As far as I am aware, the (“unadorned” ...) Perl language does not provide for any sort of “implicit wrappers.”