chore: delete the unreachable duplicate of the parked-retry block

PoolNode::fire_once carried the pending_ retry block twice, verbatim. The
first copy returns on every path through it — parked, drained, or not
pending at all — so the second was dead code from the moment it appeared.
PoolObjectNode, which is otherwise a line-for-line twin of PoolNode, has it
once.

No behaviour change; the deleted 25 lines were unreachable. Worth doing
before the fixes queued behind it, each of which has to be applied once per
copy of this function.

The duplication is a symptom: PoolNode and PoolObjectNode are ~400 lines of
near-identical code maintained by parallel edit, and a block getting pasted
twice into one of them is exactly the failure that arrangement invites.
Factoring the shared body out is a larger change and wants its own review.

include/kpn/pool_node.hpp

@@ -446,35 +446,6 @@ private:
             }
         }
 
-        // Parked from a previous firing: retry that value before touching the
-        // inputs. Returning here releases the worker — the channel's space
-        // callback re-submits this node once the consumer drains a slot.
-        if constexpr (!std::is_void_v<return_raw>) {
-            if (pending_) {
-                push_outputs(std::move(*pending_), std::make_index_sequence<output_count>{});
-                release_and_recheck();
-                if (pending_) {
-                    // Close the lost-wakeup race: a space_callback that fired
-                    // between the failed push and clearing queued_ was
-                    // swallowed, and nothing else will wake this node. Re-check
-                    // now that the flag is down.
-                    if (outputs_have_space(std::make_index_sequence<output_count>{}))
-                        try_submit(0.5f);
-                    return;                    // parked
-                }
-                // Drained: resume normal firing, resubmitting exactly the way
-                // the normal tail below does. An unconditional try_submit here
-                // would fire a node whose inputs are empty, and pop_inputs
-                // reports an empty channel as ChannelClosedError — which this
-                // node treats as "upstream finished" and self-stops on. That
-                // is a live node killing itself purely because it was woken by
-                // *output* space rather than by input arrival.
-                if constexpr (input_count == 0) try_submit(0.5f);
-                else                            on_input_ready();
-                return;
-            }
-        }
-
         // Woken by output space rather than by input arrival, with nothing
         // parked left to flush: there is no work to do. Falling through would
         // read an empty channel, and pop_one reports empty as