benchmark:

#!/usr/bin/env perl -l

use warnings;
use strict;
use Benchmark qw/timethese cmpthese/;
use Test::More;

my @az = ('a'..'z', 'A'..'Z', '1'..'9');    # note: if '0' is in your 
+alphabet, chop() will fail
my @golden_original;
my $N = 200;
for( 1 .. $N ) {
    push @golden_original,  join '', map { $az[rand @az] } 1..$N;
}
#print length($str), qq(\t"$str");
#print scalar @golden_original;
                                           #diag explain org => \@gold
+en_original;
my $wch = [with_chop  (@golden_original)]; #diag explain wch => $wch;
my $wsp = [with_split (@golden_original)]; #diag explain wsp => $wsp;
my $wsu = [with_substr(@golden_original)]; #diag explain wsu => $wsu;
is_deeply( $wsp, $wch, 'split vs chop');
is_deeply( $wsu, $wch, 'substr vs chop');

sub with_split {
    my @original = @_;
    my @transposed;
    for( @original ) {
        my $i = 0;
        $transposed[$i++] .= $_ for split //;
    }
    return @transposed;
}
sub with_chop {
    my @original = @_;
    my @transposed;
    for( map $_ = reverse, @original ){
        my $i = 0;
        $transposed[ $i ++ ] .= chop while $_;
    }
    return @transposed;
}
sub with_substr {
    my @original = @_;
    my $w = scalar @original;
    my @transposed = ( ' 'x$w ) x $w;
    for my $i ( 0 .. $#original ) {
        for my $j ( 0 .. $i ) {
            substr($transposed[$i], $j, 1) = substr($original[$j], $i,
+ 1);
            substr($transposed[$j], $i, 1) = substr($original[$i], $j,
+ 1);
        }
    }
    return @transposed;
}

my $r = timethese( 1000, {
    with_substr  => sub { with_substr( @golden_original ); },
    with_split   => sub { with_split ( @golden_original ); },
    with_chop    => sub { with_chop  ( @golden_original ); },
});
cmpthese $r;

done_testing();
[download]

 with_chop:  5 wallclock secs ( 5.19 usr +  0.00 sys =  5.19 CPU) @ 19
+2.79/s (n=1000)

with_split: 13 wallclock secs (13.14 usr +  0.02 sys = 13.16 CPU) @ 76
+.01/s (n=1000)

with_substr:  7 wallclock secs ( 6.89 usr +  0.00 sys =  6.89 CPU) @ 1
+45.14/s (n=1000)

              Rate  with_split with_substr   with_chop
with_split  76.0/s          --        -48%        -61%
with_substr  145/s         91%          --        -25%
with_chop    193/s        154%         33%          --
[download]

I am no good with pack/unpack, otherwise, I would have tested LanX's suggestion, too. From what I remember in past benchmarks, that pair usually beats substr.