Gaia, 25 bytes

ṇ+†ṅ⟨)₌¤:~+4ṛ⟨ṛ₌¤⟩ₓ⟩¦$

Try it online!

Thanks to Kevin Cruijssen for pointing out 2 bugs!

ṇ				| delete the last character from the input

  +†				| push the input again and concatenate together, so for instance

				| 'abc' 'bc' becomes ['ab' 'bc' 'c']

    ṅ				| delete the last element

       ⟨       		⟩¦	| for each of the elements, do:

	)₌			| take the first character and push again

	  ¤			| swap

	   :			| dup

	    ~			| swap case

	     +			| concatenate strings

	      4ṛ		| select a random integer from [1..5]

	        ⟨    ⟩ₓ		| and repeat that many times

		 ṛ₌¤		| select a random character from the string

		       	| clean up stack

			   $	| convert to string

Note that 4ṛ is because ṛ is implemented for an integer z as python's random.randint(1,z+1), which returns an integer N such that 1<=N<=z+1.

APL (dzaima/APL), 23 bytes

Anonymous tacit prefix function.

∊2(⊣,{?4⍴⍨?5}⊇,,-⍤,)/

Try it online!

2(…)/ apply the following infix tacit function between each character pair:

 - the switchcase

 ⍤ of

 , the concatenation of the pair

 ,, prepend the concatenation of the pair to that

 {…}⊇ pick the following elements from that:

  ?5 random number in range 1…5

  4⍴⍨ that many fours

  ? random indices for those

∊ ϵnlist (flatten)

Perl 6, 60 bytes

{S:g{.)>(.)}=$/~[~] roll ^5 .roll+1,$/.lc,$/.uc,$0.lc,$0.uc}

Try it online!

The lowercase/uppercase part is kinda annoying.

Jelly, 12 bytes

;Œsṗ5X¤XṭṖµƝ

Try it online!

Bash, 121 bytes

-20 bytes thanks to Nahuel

-9 bytes thanks to roblogic

for((i=0;i<${#1};i++)){

s=${1:i:1}

m=${1:i:2}

m=${m,,}${m^^}

for((t=0;t++<RANDOM%6;)){

s+=${m:RANDOM%4:1}

}

printf "$s"

}

Try it online!

Original answer

Bash, 150 bytes

Have done very little golf bashing and trying to improve my bash, so any comments welcome.

for((i=0;i<${#1}-1;i++));do

c=${1:$i:1}

n=${1:$((i+1)):1}

a=($n ${c,} ${c^} ${n,} ${n^})

shuf -e ${a[@]} -n "$(shuf -i 1-5 -n 1)"|xargs printf %s

done

Try it online!

Code is straightforward loop through chars setting current c and next n character, then creating an array of the 4 possibilities, repeating one of them so there's exactly 5. Next we shuffle that array, and then choose n elements from it, where n itself is random between 1 and 5.

Python 2, 107 bytes

f=lambda s:s and s[0]+''.join(sample((s[:2]+s[:2].swapcase())*5,randint(1,5)))+f(s[1:])

from random import*

Try it online!

05AB1E, 18 17 bytes

ü)vyн5LΩFyD.š«Ω]J

Inspired by @Giuseppe's Gaia answer.

-1 byte thanks to @Shaggy.

Try it online 10 times or verify all test cases 10 times.

Explanation:

ü)             # Create all pairs of the (implicit) input

               #  i.e. "Hello" → [["H","e"],["e","l"],["l","l"],["l","o"]]

  v            # Loop over each these pairs `y`:

   yн          #  Push the first character of pair `y`

   5LΩ         #  Get a random integer in the range [1,5]

      F        #  Inner loop that many times:

       y       #   Push pair `y`

        D.š«   #   Duplicate it, swap the cases of the letters, and merge it with `y`

            Ω  #   Then pop and push a random character from this list of four

  ]J           # After both loops: join the entire stack together to a single string

               # (which is output implicitly as result)

Charcoal, 27 bytes

ＦＬθ«Ｆ∧ι⊕‽⁵‽⭆✂θ⊖ι⊕ι¹⁺↥λ↧λ§θι

Try it online! Link is to verbose version of code. Explanation:

ＦＬθ«

Loop over all of the indices of the input string.

Ｆ∧ι⊕‽⁵

Except for the first index, loop over a random number from 1 to 5 inclusive...

‽⭆✂θ⊖ι⊕ι¹⁺↥λ↧λ

... extract the previous and next characters from the string, take the upper and lower case versions, and pick a random character of the four.

§θι

Print the character at the current index.

perl 5 (-p), 77 bytes

s/(.)(?=(.))/$x=$1;'$x.=substr"U$1$2L$1$2",4*rand,1;'x(1+5*rand)/gee;s/.$//

TIO

Japt -P, 14 bytes

äÈ+Zu pv ö5ö Ä

Try it

äÈ+Zu pv ö5ö Ä     :Implicit input of string

ä                  :Take each consectutive pair of characters

 È                 :Pass them through the following function as Z

  +                :  Append to the first character of the pair

   Zu              :    Uppercase Z

      p            :    Append

       v           :      Lowercase

         ö         :    Get X random characters, where X is

          5ö       :      Random number in the range [0,5)

             Ä     :      Plus 1

                   :Implicitly join and output

Python 3, 167 bytes

from random import*;c=choice

def f(s):

 i=0;r=""

 for i in range(len(s)-1):

  r+=s[i]

  for j in range(randrange(5)):r+=c([str.upper,str.lower])(c(s[i:i+2]))

 return r

Try it online!

Jelly, 14 bytes

;;;Œs$Xɗ¥5X¤¡Ɲ

Try it online!

Explanation

             Ɲ | For each overlapping pair of letters

;              | Join the first letter to...

         5X¤¡  | Between 1 and 5 repetitions of...

      Xɗ¥      | A randomly selected character from...

 ;;Œs$         | A list of the two letters and the swapped case versions of both

C(GCC) 175 162 bytes

-12 bytes from LambdaBeta

f(s,S,i,r,a)char*s,*S,*i;{srand(time(0));for(i=S;*(s+1);++s){*i++=*s;for(r=rand()%5+1;r--;*i++=rand()&1?a>96&a<123|a>64&a<91?a^32:a:a)a=rand()&1?*s:*(s+1);}*i=0;}

Try it online

Scala 2.12.8, 214 bytes

Golfed version:

val r=scala.util.Random;println(readLine.toList.sliding(2).flatMap{case a :: b :: Nil=>(a +: (0 to r.nextInt(5)).map{_=>((c: Char)=>if(r.nextBoolean)c.toUpper else c.toLower)(if(r.nextBoolean)a else b)})}.mkString)

Golfed with newlines and indents:

val r=scala.util.Random

println(readLine.toList.sliding(2).flatMap{

  case a :: b :: Nil=>

    (a +: (0 to r.nextInt(5)).map{_=>

      ((c: Char)=>if(r.nextBoolean)c.toUpper else c.toLower)(if(r.nextBoolean)a else b)

    })

}.mkString)

Ungolfed:

import scala.io.StdIn

import scala.util.Random



def gobble(input: String): String = {

  input.toList.sliding(2).flatMap {

    case thisChar :: nextChar :: Nil =>

      val numberOfAdditions = Random.nextInt(5)

      (thisChar +: (0 to numberOfAdditions).map { _ =>

        val char = if(Random.nextBoolean) thisChar else nextChar

        val cc = if(Random.nextBoolean) char.toUpper else char.ToLower

        cc

      })

  }.mkString

}



println(gobble(StdIn.readLine()))

Perl 5 -n, 61 bytes

s/.(?=(.))/print$&,map{(map{lc,uc}$&,$1)[rand 4]}0..rand 5/ge

Try it online!

C# (Visual C# Interactive Compiler), 236 213 209 bytes

a=>{int i=0,j;var m=new Random();var s="";var c = a.Select(x=>Char.IsLetter(x)?(char)(x^32):x).ToArray();for(;i<a.Length-1;i++)for(j=m.Next(1,5);j-->0;)s+=new{a[i],c[i],a[i+1],c[i+1]}[m.Next(0,3)];return s;}

Try it online!

T-SQL query, 286 bytes

DECLARE @ char(999)='String'



SELECT @=stuff(@,n+2,0,s)FROM(SELECT

top 999*,substring(lower(c)+upper(c),abs(v%4)+1,1)s

FROM(SELECT*,number n,substring(@,number+1,2)c,cast(newid()as varbinary)v

FROM(values(1),(2),(3),(4),(5))F(h),spt_values)D

WHERE'P'=type and n<len(@)-1and h>v%3+2ORDER

BY-n)E

PRINT LEFT(@,len(@)-1)

Try it online unfortunately the online version always show the same result for the same varchar, unlike MS SQL Server Management Studio

C# (Visual C# Interactive Compiler), 156 bytes

n=>{var k=new Random();int i=0;foreach(var j in n.Skip(1).Zip(n,(a,b)=>a+b))for(Write(j[1]),i=0;i++<k.Next(5);)Write(k.Next()%2<1?j.ToUpper():j.ToLower());}

Try it online!

Japt -P, 43 16 bytes

äÈ+(Zv +Zu)ö5ö Ä

Shortened by a lot now!

Try it

C (gcc), 110 bytes

i,p;g(char*_){for(i=rand()%1024,putchar(*_);p=_[i%2],putchar(i&2&&p>64&~-p%32<26?p^32:p),i/=4;);_[2]&&g(_+1);}

Try it online!

i,p;g(char*_){

    for(i=rand()%1024,      //initialize: get 10 random bits 

         putchar(*_);       // and print current char

        p=_[i%2],           //1st bit => current/next char

         putchar(i&2&&      //2nd bit => toggle case

            p>64&~-p%32<26  // but only if char-to-print is alphabetic

            ?p^32:p),

        i/=4;);             //discard two bits; run at least once

    _[2]&&g(_+1);           //if not last char, repeat with next char

}

The number of characters printed (per input character) is not uniformly random:

1  if      i<   4 (  4/1024 = 1/256)

2  if   4<=i<  16 ( 12/1024 = 3/256)

3  if  16<=i<  64 ( 48/1024 = 3/ 64)

4  if  64<=i< 256 (192/1024 = 3/ 16)

5  if 256<=i<1023 (768/1024 = 3/  4)