05AB1E, 19 17 16 bytes

Saved 1 byte thanks to Kevin Cruijssen

áΣl}.γl}éεgyθJ}J

Try it online!
or as a Test Suite

Explanation

á                  # keep only letters in input

 Σl}               # sort by lower-case

    .γl}           # group by lower-case

        é          # sort by length (stable)

         ε    }    # map each to

          g        # its length

             J     # joined with

           yθ      # the last letter

               J   # join to string

Japt v2.0a0 -P, 14 bytes

fl üv ñÊ®ÌiZÊ

Try it

fl üv ñÊ®ÌiZÊ     :Implicit input of string

                   > e.g., "Kitkat Tango"



f                  :Split to an array of characters

 l                :  Matching RegEx /[a-z]/gi

                   > ["K","i","t","k","a","t","T","a","n","g","o"]



    ü              :Sort & group (Preserves original order within each group)

     v             :  By lowercase

                   > [["a","a"],["g"],["i"],["K","k"],["n"],["o"],["t","t","T"]]



       ñ           :Sort

        Ê          :  By length

                   > [["g"],["i"],["n"],["o"],["a","a"],["K","k"],["t","t","T"]]



         ®         :Map each Z

          Ì        :  Last element of Z

                   >   ["g","i","n","o","a","k","T"]

           i       :  Prepend

            ZÊ     :    Length of Z

                   >   ["1g","1i","1n","1o","2a","2k","3T"]



                   :Implicitly join & output

                   > "1g1i1n1o2a2k3T"

Retina, 67 66 41 bytes

[Wd_]



O$`.

$l$0

ir`1*(.)

$.0$1

N`d+.

-25 bytes and a minor bug-fix thanks to @Neil.

Try it online or verify all test cases.

Explanation:

Remove everything except for upper- and lowercase letters:

i.e. Kitkat Tango 123! → KitkatTango

[Wd_]

Sort the individual letters case-insensitive (thanks to @MartinEnder for this):

i.e. KitkatTango → aagiKknottT

O$`.

$l$0

Capture every chunk of case-insensitive repeated adjacent letters:

i.e. aagiKknottT → [aa,g,i,Kk,n,o,ttT]

ir`1*(.)

Prepend the length of every match, and only keep the last letter of every chunk:

i.e. [aa,g,i,Kk,n,o,ttT] → 2a1g1i2k1n1o3T

$.0$1

Sort the numbers and letter groups based on the numbers:
2a1g1i2k1n1o3T → 1g1i1n1o2a2k3T

N`d+.

After which the result is output implicitly.

Perl 6, 66 bytes

{[~] map {+$_~.tail},sort {+$_,.lc},values classify &lc,m:g/<:L>/}

Try it online!

Pyth, 27 24 22 bytes

srD0m+lded.gr0kf}r0TGQ

Try it online here.

srD0m+lded.gr0kf}r0TGQ   Implicit: Q=eval(input()), G=lowercase alphabet

               f     Q   Filter keep elements of Q, as T, when truthy:

                 r0T       Convert T to lowercase

                }   G      Is the above in G?

          .g             Group the remaining characters, as k, using:

            r0k             Convert k to lowercase

                             (Grouping preserves relative order)

    m                    Map the sorted groups, as d, using:

      ld                   Length of d

        ed                 Last element of d

     +                     Concatenate the previous two results

  D                      Sort the above...

 r 0                     ... by their lowercase values

s                        Concatenate the result of the above into a string, implicit print

Edit: Golfed 3 bytes by ordering by character before group, previous version: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edit 2: Golfed off another 2 bytes by formatting output before any ordering, previous version: sm+ldedlD.gr0krD0f}r0TGQ

Python 2, 99 bytes

def f(s):a=s.lower();return''.join(sorted(`a.count(c)`+s[a.rfind(c)]for c in set(a)if c.isalpha()))

Try it online!

Red, 220 196 bytes

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]rejoin sort collect[foreach c sort

unique reverse rejoin parse s[collect[any[keep[a]| skip]]][i: 0

foreach d s[if(c% 32)=(d% 32)[i: i + 1]]keep rejoin[i c]]]]

Try it online!

Perl 5, 74 68 bytes

-6 bytes changing -p to -n and using say instead of $_=join"",

s/[a-z]/($h{lc$&}+=1).=$&/gie;say sort{$a-$b||lc$a cmp lc$b}values%h

TIO

61 bytes, in case there is no more than 9 occurence of each character

s/[a-z]/($h{lc$&}+=1).=$&/gie;print sort{lc$a cmp lc$b}values%h

Jelly, 15 bytes

fØẠµŒlĠLÞịµL,Ṫ)

A full program printing the password as specified (as a monadic Link it yields a list of lists each containing an integer and a character).

Try it online!

Charcoal, 30 bytes

Ｆ⌈Ｅβ№↧θιＦβ¿⁼№↧θκ⊕ι⁺⊕ι§Φθ⁼↧λκ±¹

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

Ｆ⌈Ｅβ№↧θι

Run through the lowercase alphabet and find the highest character count in the lowercased input. Loop over the implicit range. (The loop actually goes from 0 to n-1 so I have to increment the loop variable at each use.)

Ｆβ

Loop over the lowercase alphabet again.

¿⁼№↧θκ⊕ι

If the count of the current letter is equal to the outer loop value...

⁺⊕ι§Φθ⁼↧λκ±¹

Concatenate the current count with the last occurrence of the current letter and implicitly print.