avoid leak in regex with overload and code block

When concatenating the components of a run-time pattern, if
a component has concat overloading, then that method is used, and
any previously accumulated code blocks - i.e. (?{...}) and similar -
are discarded. However, the ref counts of of any regex objects
pointed to which contained those code block(s) weren't having
their reference count decremented, and so leaked.

Spotted by code inspection while working on the previous commit.

Author: iabyn

regcomp.c

@@ -758,6 +758,9 @@ S_concat_pat(pTHX_ RExC_state_t * const pRExC_state,
              */
             struct reg_code_blocks *cbs =  pRExC_state->code_blocks;
             if (cbs) {
+                for (int n = 0; n < cbs->count; n++) {
+                    SvREFCNT_dec(cbs->cb[n].src_regex);
+                }
                 cbs->count = 0;
             }
         }

t/op/svleak.t

@@ -15,7 +15,7 @@ BEGIN {
 
 use Config;
 
-plan tests => 156;
+plan tests => 157;
 
 # run some code N times. If the number of SVs at the end of loop N is
 # greater than (N-1)*delta at the end of loop 1, we've got a leak
@@ -683,3 +683,30 @@ leak 2, 0,  sub {
                                 } } 1..2;
             },
             'sort block return';
+
+
+# Avoid leaks when overloading causes a compile-time pattern code block
+# to be recompiled at runtime.
+
+package myconcat {
+    use overload
+        '""' => sub { ${$_[0]} },
+        '.' =>  sub {
+                        my ($x, $y) = @_[ $_[2] ? (1,0) : (0,1) ];
+                        my ($xx, $yy) = ("$x", "$y");
+                        "$xx$yy";
+                    }
+        ;
+
+    ::leak(2, 0,
+        sub {
+           my $r1 = qr/(?{1})/;
+           my $r2 = qr/(?{2})/;
+           bless $r2, 'myconcat';
+           use re "eval";
+           qr/$r1$r2/;
+           1;
+        },
+        'overloaded pattern with code block'
+    );
+}