If we strip off the unix-specific header, we get:

    $s='$s=%c%s%c;%cprintf($s, 39,$s,39,10,10);%c';
    printf($s, 39,$s,39,10,10);
[download]

which is a little less cluttered, and slightly easier to read.

Here's a variant that uses Perl's q() operator, which nests without requiring token substitution:

    $s=q($s=q(%s);%cprintf ($s, $s,10,10);%c);
    printf($s, $s,10,10);
[download]

We can also use the qq() operator (which accepts \n), but this time we have to use token substitution for the dollar signs (ASCII 36). There's no other way to escape them indefinitely:

    $s=qq(%cs=qq(%s);
    printf (%cs, 36,%cs,36,36);
    );
    printf ($s, 36,$s,36,36);
[download]

And finally, here's the simplest possible version, using q() again, with literal newlines:

    $s=q($s=q(%s);
    printf ($s,$s);
    );
    printf ($s,$s);
[download]

<update>I didn't mean to suggest that this was the smallest possible Perl quine, though I see how the text could be interpreted that way. All I meant to say was that the above code is the simplest version of this particular self-referential Perl statement. Self-reference and its cousin mutual coreference are much more interesting than simple self-replication, IMO. </update>

The trick of using placeholders and substitution is actually one of the deep mysteries of computer programming. The basic idea is simple enough, but the implications (like being able to make infinitely recursive, self-referential strings) are profound.