void overload_inc($V * object, SV * second, SV * switch) {
   /* code that adds 1 to the value held by object */ 
}
[download]

void overload_plus_eq(SV * object, SV * addon, SV * switch) {
   /*code that adds the value of addon to the value held by object */
}
[download]

D:\>perl -Mwarnings -Moverload -e "use overload 'fu' => sub {return 1}
+;"
overload arg 'fu' is invalid at -e line 1.

D:\>perl -Mwarnings -Moverload -e "use overload '&.' => sub {return 1}
+;"

D:\>perl -Mwarnings -Moverload -e "use overload '&.=' => sub {return 1
+};"

D:\>
[download]

I'd suggest PDL is the ultimate operator-overloader "source of truth". Mutating overloads is implemented in PDL::Ops, specifically (https://github.com/PDLPorters/pdl/blob/ad2783ad4b00583f14af3a3c24a93bb9f1a4ff33/Basic/Ops/ops.pd#L191-L196):

    $ret .= pp_line_numbers(__LINE__, <<EOF) if $mutator;
BEGIN {
# in1, in2, out, swap if true
\$OVERLOADS{'$op='} = sub { PDL::$name(\$_[0]->inplace, \$_[1]); \$_[0
+] };
}
EOF
[download]

Modifying the generated code for += to this:

#line 192 "ops.pd"
BEGIN {
# in1, in2, out, swap if true
$OVERLOADS{'+='} = sub {
use Carp; use Test::More; diag "RUN ", Test::More::explain \@_;
PDL::plus($_[0]->inplace, $_[1]); $_[0] };
}
[download]

and running it like this:

$ perl -MPDL -e '$p=pdl(1); $p+=2'
[download]

gives:

# RUN [
#   bless( do{\(my $o = '94749946365136')}, 'PDL' ),
#   2,
#   undef
# ]
[download]

so your XS function should work. Did you make an overload for +=?

In Math::GMPz, the overloading of '++' is:

void overload_inc(pTHX_ SV * p, SV * a, SV * b) {
     mpz_add_ui(*(INT2PTR(mpz_t *, SvIVX(SvRV(p)))), *(INT2PTR(mpz_t *
+, SvIVX(SvRV(p)))), 1);
}
[download]

which is simply doing p = p + 1, with "p" being a Math::GMPz object.
Then, in the bottom section of the XS file I have:

void
overload_inc (p, a, b)
    SV *    p
    SV *    a
    SV *    b
        CODE:
        overload_inc(aTHX_ p, a, b);
        XSRETURN_EMPTY; /* return empty stack */
[download]

Works fine.
For the overloading of '+=', it gets a bit drawn out because we might be adding on something other than an IV.
But if we were just dealing with adding on an unsigned long int we would actually have:

SV * overload_add_eq(pTHX_ SV * p, SV * a, SV * b) {
     mpz_add_ui(*(INT2PTR(mpz_t *, SvIVX(SvRV(p)))), *(INT2PTR(mpz_t *
+, SvIVX(SvRV(p)))), SvUV(a));
     SvREFCNT_inc(p);
     return p;
}
[download]

which is just doing p = p + a, and returning p (after increasing the refcount).
The corresponding code in the bottom section of the XS file would be:

SV *
overload_add_eq (p, a, b)
    SV *    p
    SV *    a
    SV *    b
CODE:
  RETVAL = overload_add_eq (aTHX_ p, a, b);
OUTPUT:  RETVAL
[download]

Now, it's not hard to work out what that overload_add_eq() would look like if I were to apply the same approach as used by overload_inc():

void overload_add_eq(pTHX_ SV * p, SV * a, SV * b) {
     mpz_add_ui(*(INT2PTR(mpz_t *, SvIVX(SvRV(p)))), *(INT2PTR(mpz_t *
+, SvIVX(SvRV(p)))), SvUV(a));
}
[download]

and

void
overload_add_eq (p, second, third)
    SV *    p
    SV *    a
    SV *    b
        CODE:
        overload_add_eq(aTHX_ p, a, b);
        XSRETURN_EMPTY; /* return empty stack */
[download]

But I've never managed to get that to work.
It has, however, been a while since I've tried - so I'll have another crack at it tomorrow (as it's now getting late over here) and see if I can get lucky.
(I can't actually remember just what the problem is.)

BTW, I've fiddled about with that code that I've posted, so it might contain one or more typos.

Cheers,
Rob