JavaScript (ES6), 85 bytes

The output string is in lowercase.

s=>(g=(c,x=+('0x'+s[--n])+!!c)=>1/x?g(x>>4)+(x&15).toString(16):~n?g(c)+'-':'')(n=36)

Try it online!

Commented

s => (                   // s = GUID

  g = (                  // g = recursive function taking:

    c,                   //   c = carry from the previous iteration

    x = +('0x' + s[--n]) //   x = decimal conversion of the current digit

        + !!c            //       add the carry

  ) =>                   //

    1 / x ?              // if x is numeric:

      g(x >> 4) +        //   do a recursive call, using the new carry

      (x & 15)           //   and append the next digit

      .toString(16)      //   converted back to hexadecimal 

    :                    // else:

      ~n ?               //   if n is not equal to -1:

        g(c)             //     do a recursive call, leaving the current carry unchanged

        + '-'            //     and append a hyphen

      :                  //   else:

        ''               //     stop recursion

)(n = 36)                // initial call to g with n = 36 and a truthy carry

APL (Dyalog Unicode), 46 bytes^SBCS

Anonymous tacit prefix function.

⎕CY'dfns'

(∊1hex 16(|+1⌽=)⍣≡1+@32dec¨)@('-'≠⊢)

Try it online!

⎕CY'dfns' copy the "dfns" library (to get hex and dec)

(…)

 ⊢ the argument

 ≠ differs from

 '-' a dash
(…)@ on the subset consisting of the locations at which the above criterion is true, apply:

 dec¨ convert each hexadecimal character to a decimal number

 …@32 at position 32 (the last digit), apply:

  1+ increment

 16(…)⍣≡ repeatedly apply with left argument 16 until stable:

  = compare (gives mask where the hexadecimal digits are 16)

  1⌽ cyclically rotate one step left (this is the carry bit)

  |+ to that, add the division remainder when divided (by sixteen, thus making all 16 into 0)

 1hex  turn digits into length-one hexadecimal character representations

 ∊ ϵnlist (flatten)

05AB1E, 17 15 bytes

Saved 2 bytes thanks to Kevin Cruijssen

'-KH>hŽ¦˜S·£'-ý

Try it online!
or as a Test Suite

Explanation

'-K               # remove "-" from input

   H              # convert from hex to base 10

    >             # increment

     h            # convert to hex from base 10

      Ž¦˜S·       # push [8, 4, 4, 4, 12]

           £      # split into parts of these sizes

            '-ý   # join on "-"

Perl 6, 65 bytes

{(:16(TR/-//)+1).base(16).comb.rotor(8,4,4,4,*)».join.join('-')}

Test it

Python 2, 53

from uuid import*

print UUID(int=UUID(input()).int+1)

Try it online!

Python 2, 113 112 bytes

def f(s):a=hex(int(s.replace('-',''),16)+1+2**128);return'-'.join((a[3:11],a[11:15],a[15:19],a[19:23],a[23:-1]))

Try it online!

Without imports

Retina 0.8.2, 21 bytes

T`FfdlL`0dlL`.[-Ff]*$

Try it online! Link includes test cases. 9 becomes a. Explanation: The regex matches all trailing fs and -s plus one preceding character. The transliteration then cyclically increments those characters as if they were hex digits. Alternate approach, also 21 bytes:

T`L`l

T`fo`dl`.[-f]*$

Try it online! Link includes test cases. Works by lowercasing the input to simplify the transliteration. Would therefore be 15 bytes if it only had to support lowercase. Try it online! Link includes test cases.

MATLAB, 138 bytes

a=1;Z=a;for q=flip(split(input(''),'-'))'

z=dec2hex(hex2dec(q)+a);if nnz(z)>nnz(q{:})

z=~q{:}+48;else

a=0;end

Z=[z 45 Z];end;disp(Z(1:36))

Explanation

The hex2dec function spits out a double, so it cannot process the entire GUID at once to avoid exceeding flintmax. Instead, we have to process the GUID chunk by chunck, using split. The variable a checks if we need to carry a one, and cheatingly also is the initial increment we add. The condition for carrying over is whether the lengths of the original and incremented strings are no longer equal.

Original version was just under 160 bytes so I'd like to think this should not be easy to outgolf.

Ruby -pl, 62 57 bytes

$_=(1+gsub(?-,"").hex).to_s 16

7.step(22,5){|i|$_[i]+=?-}

Try it online!

Java 11, 152 149 bytes

s->{var t=new java.math.BigInteger(s.replace("-",""),16);return(t.add(t.ONE).toString(16)).replaceAll("(.{4})".repeat(5)+"(.*)","$1$2-$3-$4-$5-$6");}

Try it online.

Explanation:

s->{                              // Method with String as both parameter and return-type

  var t=new java.math.BigInteger( //  Create a BigInteger

         s.replace("-",""),       //  Of the input-string with all "-" removed

         16);                     //  Converted from Hexadecimal

  return(t.add(t.ONE)             //  Add 1

         .toString(16))           //  And convert it back to a Hexadecimal String

         .replaceAll("(.{4})".repeat(5)+"(.*)",

                                  //  And split the string into parts of sizes 4,4,4,4,4,rest

           "$1$2-$3-$4-$5-$6");}  //  And insert "-" after parts of size 8,4,4,4,

                                  //  and return it as result