podcheck.t: Fix multiple link targets bug

podcheck.t would wrongly warn about duplicate link targets.  It is
ambiguous if you have, say

 =head1 foo
 ...
 =item foo

and then try to create a link to 'foo'.  Which 'foo' should it go to?
So podcheck looks for such ambiguous links.  However, it was incorrectly
warning on

 =head1 foo
 ...
 =item * foo

 The latter is a bullet list, which is not an appropriate link target.
 The logic was flawed in the node() method, when it encountered the
 second foo, it didn't realize it was for a bullet list, and pushed it
 onto a list which caused the count to be larger than 1, which caused it
 later to think there were two link targets with the same name.

 The solution here is to instead note that linkable targets are only in
 =headN or definition lists.  The acquisition of the names of them are
 moved to the methods that get called upon the termination of each of
 these by the parsing routines.  The count is incremented at that point.
 This means the node() method extension no longer does anything useful
 and is removed; as well as an auxiliary field, linkable_item.  We no
 longer need to distinguish between =headN and =item.

Author: khwilliamson

t/porting/podcheck.t

@@ -697,8 +697,6 @@ package My::Pod::Checker {      # Extend Pod::Checker
     my %in_NAME;            # true if within NAME section
     my %in_begin;           # true if within =begin section
     my %in_X;               # true if in a X<>
-    my %linkable_item;      # Bool: if the latest =item is linkable.  It isn't
-                            # for bullet and number lists
     my %linkable_nodes;     # Pod::Checker adds all =items to its node list,
                             # but not all =items are linkable-to
     my %running_CFL_text;   # The current text that is being accumulated until
@@ -726,7 +724,6 @@ package My::Pod::Checker {      # Extend Pod::Checker
         delete $in_for{$addr};
         delete $in_NAME{$addr};
         delete $in_X{$addr};
-        delete $linkable_item{$addr};
         delete $linkable_nodes{$addr};
         delete $running_CFL_text{$addr};
         delete $running_simple_text{$addr};
@@ -750,7 +747,6 @@ package My::Pod::Checker {      # Extend Pod::Checker
         $in_X{$addr} = 0;
         $in_CFL{$addr} = 0;
         $in_NAME{$addr} = 0;
-        $linkable_item{$addr} = 0;
         $seen_pod_cmd{$addr} = 0;
         return $self;
     }
@@ -932,16 +928,11 @@ package My::Pod::Checker {      # Extend Pod::Checker
         $start_line{$addr} = $_[0]->{start_line};
         $running_CFL_text{$addr} = "";
         $running_simple_text{$addr} = "";
-
     }
 
     sub start_item_text {
         my $self = shift;
         start_item($self);
-        my $addr = refaddr $self;
-
-        # This is the only =item that is linkable
-        $linkable_item{$addr} = 1;
 
         return $self->SUPER::start_item_text(@_);
     }
@@ -960,7 +951,34 @@ package My::Pod::Checker {      # Extend Pod::Checker
         return $self->SUPER::start_item_bullet(@_);
     }
 
-    sub end_item {  # No difference in =item types endings
+    sub clean_up_node_name_ {
+        my $text = shift;
+        $text =~ s/\s+$//;      # strip trailing space
+        $text =~ s/\s{2,}/ /gs; # collapse whitespace
+        return $text;
+    }
+
+    sub end_head  {
+        my $self = shift;
+        my $addr = refaddr $self;
+        $running_simple_text{$addr} =
+                               clean_up_node_name_($running_simple_text{$addr});
+        $linkable_nodes{$addr}{$running_simple_text{$addr}}++;
+
+        return $self->SUPER::end_head(@_);
+    }
+
+    sub end_item_text {
+        my $self = shift;
+        my $addr = refaddr $self;
+        $running_simple_text{$addr} =
+                              clean_up_node_name_($running_simple_text{$addr});
+        $linkable_nodes{$addr}{$running_simple_text{$addr}}++;
+
+        return $self->SUPER::end_item_text(@_);
+    }
+
+    sub end_item {
         my $self = shift;
         check_see_but_not_link($self);
         return $self->SUPER::end_item(@_);
@@ -1378,20 +1396,6 @@ package My::Pod::Checker {      # Extend Pod::Checker
         return $self->SUPER::hyperlink($link);
     }
 
-    sub node {
-        my $self = shift;
-        my $text = $_[0];
-        if($text) {
-            $text =~ s/\s+$//s; # strip trailing whitespace
-            $text =~ s/\s+/ /gs; # collapse whitespace
-            my $addr = refaddr $self;
-            push(@{$linkable_nodes{$addr}}, $text) if
-                                    ! $current_indent{$addr}
-                                    || $linkable_item{$addr};
-        }
-        return $self->SUPER::node($_[0]);
-    }
-
     sub get_current_indent {
         return $INDENT + $current_indent{refaddr $_[0]};
     }
@@ -1403,7 +1407,7 @@ package My::Pod::Checker {      # Extend Pod::Checker
     sub linkable_nodes {
         my $linkables = $linkable_nodes{refaddr $_[0]};
         return undef unless $linkables;
-        return @$linkables;
+        return $linkables;
     }
 
     sub get_skip {
@@ -2048,10 +2052,10 @@ foreach my $filename (@files) {
         }
 
         # Go through everything in the file that could be an anchor that
-        # could be a link target.  Count how many there are of the same name.
-        foreach my $node ($checker->linkable_nodes) {
-            next FILE if ! $node;        # Can be empty is like '=item *'
-            $nodes{$name}{$node}++;
+        # could be a link target.
+        my $linkables = $checker->linkable_nodes;
+        foreach my $node (keys $linkables->%*) {
+            $nodes{$name}{$node} = $linkables->{$node};
 
             # Experiments have shown that cpan search can figure out the
             # target of a link even if the exact wording is incorrect, as long