This isn't 100% accurate (for that, you should thumb through the docs or --the horror!-- Perl's source), purposely omitting things for brevity, but it should give a decent idea how the above one-liner works.

-e tells Perl should use the next argument as the code to execute rather than reading some in from a script.

$_ = "@F[1,0]";

... with "@F[1,0]" really just being a Perl idiom for ...

$_ = join( $", $F[1], $F[0] );

... where $" is, by default, set to a single space.

-p then wraps our code inside a while loop, assigning each line of files we specify after our code (ie, test.txt) to $_ and then printing $_ back out afterwards.

while (<>) {
    $_ = join( $", $F[1], $F[0] );
} continue {
    print $_;
}

And since we change the contents of $_, our replacement gets printed instead of the original line!

So that we don't have to worry about line endings, -l is used to autochomp each line, and suffix all prints with $\ ("\n" in this instance, as we're reading line by line).

while (<>) {
    chomp $_;
    $_ = join( $", $F[1], $F[0] );
} continue {
    print $_, $\;
}

-a then tells Perl to autosplits each line into the @F array.

while (<>) {
    chomp $_;
    @F = split( ' ', $_ );
    $_ = join( $", $F[1], $F[0] );
} continue {
    print $_, $\;
}

However, since we don't want -a to split on whitespace (the default), we use -F, to change our split pattern to commas instead.

while (<>) {
    chomp $_;
    @F = split( /,/, $_ );
    $_ = join( $", $F[1], $F[0] );
} continue {
    print $_, $\;
}

Finally, -i is used to do an "in-place edit" on all files parsed with the <>-operator. (See also $ARGV.)

$extension = $i_flag; # -i.bak
while (<>) {
    if ( $ARGV ne $oldargv ) {
        $backup = $ARGV . $extension;
        rename( $ARGV => $backup );
        open   ARGVOUT, ">$ARGV";
        select ARGVOUT;
        $oldargv = $ARGV;
    }
    chomp $_;
    @F = split( /,/ => $_ );
    $_ = join( $" => $F[1], $F[0] );
} continue {
    print $_, $\;
}
select STDOUT;