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.

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!

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)

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)

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.

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 bytes

#define R=rand(0)
char*i,S[999];r,a;f(char*s)srand(time(0));for(i=S;*(s+1);++s)a>64&a<91?a^32:a:a)a R&1?*s:*(s+1);*i=0;return S;

Try it online

Japt v2.0a0, 43 bytes

s0UÊÉ)rÈ+Y+(C=[Yu Yv T=UgZÄ v Tu] cMq5 £C ö

After a month of so of Japt, I'm still not very good at it.

Try it

R, 179 bytes

l=strsplit(s, "")[[1]];paste(unlist(sapply(1:nchar(w),function(i)sample(c(tolower(l[i:min(i+1,
 nchar(w))]),toupper(l[i:min(i+1,nchar(w))])),sample(5,1),replace=TRUE))),collapse="")

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

a=>int i=0;char b=a[0];var m=new Random();var s="";for(;i<a.Length;)for(dynamic j=m.Next(1,5),d=new []b,(char)(b^32),(b=a[i++]),(char)(b^32);j-->0;)s+=d[m.Next(0,3)];return s;

Try it online!

Jelly, 12 bytes

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

Try it online!

Scala 2.12.8, 214 bytes

Golfed version:

val r=scala.util.Random;println(readLine.toList.sliding(2).flatMapcase 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()))