what I thought I'd done was to describe in broad terms what I consider to be the attributes of good commenting,

Your opening line is:

"It is indeed a sad state of affairs when programmers fail to properly comment as they write code."

And that sets the tone for the entire post.

For the rest. When I encounter modules that contain that much verbiage I often just delete it without reading it.

Especially when I encounter comments like

  # Reverse sort the set and partitions and insert sums
[download]

To "document":

  @$rs = reverse sort numerically @$rs ;
  @a   = ($sa, reverse sort numerically @a) ;
  @b   = ($sb, reverse sort numerically @b) ;
[download]

• Reverse: This keyword precedes all three sorts.

  It is redundant.

• sort: as is this.
• the set: if @$rs was @$set, this word becomes redundant.
• and partitons: Ditto these, if @a and @b where @partA and @partB.

  Especially if the sub were called partitionShuffled() rather than hack_C.

• And insert sums: Ditto if $sa and $sb where $sumA & $sumB.

Three lines of verbiage (including 2 blanks) mostly redundant. And completely redundant if the documentation is placed in the only verifiable content of the file--the code.

And

  # Done -- return partitins in required order
[download]

to "document"

  if ($a[0] >= $b[0]) { return (\@a, \@b) ; }
                 else { return (\@b, \@a) ; } ;
} ;
[download]

• Done --: The end of the subroutine and your done. No shit Sherlock!
• return: And your going to return something. Cool.

  The fact that you use return in the code (twice) is a pretty clear clue.

• partitins: @partA & partB would be so much better.
• in required order: Required for what? By whom?

  You mean partition A then partition B if the sum of A is greater or equal to the sum of B. Or vice versa otherwise.

• (And what's with that floating semicolon after the subroutine?)

Again, mostly redundant, with the code being far clearer than the "documentation".

And the whole lot would be clearer still (and far more efficient to boot), written as:

    # Sort the callers array in-place
    @$set = sort{ $b<=>$a } @$set;

    return $sumA >= $sumB 
        ? ([ $sumA, sort{ $b<=>$a } @partA ], [ $sumB, sort{ $b<=>$a }
+ @partB ])
        : ([ $sumB, sort{ $b<=>$a } @partB ], [ $sumA, sort{ $b<=>$a }
+ @partA ])
    ;
}
[download]