With that tip, here is an answer in 90 characters:

sub P {
my($n,$i)=@_;$i||=$n;$i-1?map{my$c=$_;map[($i)x$c,@$_],P($n-$c*$i,$i-1
+)}0..$n/$i:[(1)
x$n]
}
[download]

Well, if I'm allowed to generate a list of strings rather than a list of lists, then I'll kick off the golfing with a strict compliant one in 70 characters (inside of P):

#!/usr/bin/perl -w
use strict;

sub P {
my($i)=@_;push@_,grep!/[^1-$i]/,map"$i$_",P($_[0]-$i)and$i--while$i;@_
}

for(P(5)){
    print "$_\n";
}
__END__
# output is

5
41
32
311
221
2111
11111
[download]

If you do insist on a list of lists, we can tack on the following 16 character wrapper sub to call instead of P:

sub W{map{[split//]}&P}
[download]

Update: In response to my major oversight that tilly's followup points out, all I can say is:
"Rats! Last time I go golfing in the middle of the night!"
:-)

Update2:Ok, in the light of day, here's a recursive one in 82 chars (ignoring unnecessary whitespace) that returns a list of lists:

sub P{
 my$i=my$n=pop;
 push@_,grep{!grep{$_>$i}@$_}map{[$i,@$_]}P($n-$i)while$i-->1;
 [$n],@_
}
[download]

Cute idea, but your output from P(11) is..ambiguous.

And P(12) has the incorrect "1011" entry for 10, 11.

UPDATE
Nice improvement. It can indeed be compressed. Here is 74 characters:

sub P{
my$n=pop;[$n],map{my$i=$_;grep{!grep$_>$i,@$_}map[$i,@$_],P($n-$i)}1..
+$n-1
}
[download]

Hmm, and we can shave that down to 71 chars:

sub P{
[@_],map{my$i=$_;grep{!grep$_>$i,@$_}map[$i,@$_],P($_[0]-$i)}1..$_[0]-
+1
}
[download]

sub P {
$_[0]?map{my$c=$_;map[$c,@$_],P($_[0]-$c)}(1..$_[0]):[]
}
[download]

sub P {
my$b=$_[1]||$_[0];
$_[0]?map{my$c=$_;map[$c,@$_],P($_[0]-$c,$c)}grep{$_<=$b}(1..$_[0]):[]
}
[download]

The first is a non-solution in my books, but the second is very good. But I was wondering if it was possible to do a reasonable non-recursive solution, and at 87 by my count, 94 counting the body, it seems like the best so far.

sub P{
$n=pop;@a=[0];map{$i=$_;push@{$a[$i+$_]},map[$i,@$_],@{$a[$_]}for
0..$n}1..$n;@{$a[$n]}
}
[download]

I keep on thinking this should be improvable, but darned if I can see it.

Rule #7 for sociopathic obsessive compulsives is "If you can't win, change the rules".

So here is a context-free iterator that produces all unique partitionings along with a golfed version of it:

#!/usr/bin/perl -w
use strict;

sub ipart {
    my( @a, $n )= @_;
    while(  $n++, 0 == --$a[$#a]  ){
        $n += pop @a;
        return   if  ! @a;
    }
    do {
        push @a, @a && $a[$#a] < $n ? $a[$#a] : $n;
        $n -= $a[$#a];
    } while(  0 < $n  );
    return @a;
}

sub ip {
my(@a,$n)=@_;$n+=shift@a while$n++,@a&&!--$a[0];
{@a||last;@a=($a[0]<$n?$a[0]:$n,@a);($n-=$a[0])&&redo}@a
}

for(  @ARGV  ) {
    print "$_:\n";
    my @p= $_;
    do {
        print "  [",join(",",@p),"]\n";
    } while(  @p= ipart( @p )  );
    print "$_:\n";
    @p= $_;
    do {
        print "  [",join(",",@p),"]\n";
    } while(  @p= ip( @p )  );
}
[download]

An iterator returns partitionings one at a time. "Context-free" means that all you have to pass subsequent calls to the iterator is the previously returned iterator.

Normally the first call to the iterator is a special case that initializes it and returns the first solution. In this case I cheat a little since ipart($n) looks like an initialization but can also be considered as passing in the first solution, I just start by returning the second solution.

Anyway, feel free to golf that down from the 104-character version I came up with (since the newline is not required).