Brain-Flak, 188 bytes

<>((((()()()){}){}()){}){(({}[()])<({}[(((((()()()()()){}){}){})()){}{}])<>{<>(({})<({}<>({}<>))((){[()](<{}>)}{}){{}(<({}<([]<<>{({}<>)<>}<>>){({}[()]<({}<>)<>>)}{}>)>)}{}>)<>}<>{}<>>)}<>

Try it online!

In addition to the reflections described in the challenge specification, this code also reverses the string exactly 26 times. This has no effect on the final output.

# Push 26
<>((((()()()){}){}()){})

# Do 26 times:
{(({}[()])<

  # Subtract 122 from counter to get negative lowercase letter
  ({}[(((((()()()()()){}){}){})()){}{}])

  # For each character in string:
  <>{

    # Keep a copy of pivot letter on the third stack
    <>(({})<

    # Move next letter to other stack and compare to pivot
    ({}<>({}<>))

    # If letters are equal:
    ((){[()](<{}>)}{}){

      # Keep current letter separate from this transformation
      {}(<({}<

      # While keeping a copy of current stack height:
      ([]<

        # Move all letters to one stack
        <>{({}<>)<>}<>

      >)

      # Move a number of letters equal to old stack height back
      {({}[()]<({}<>)<>>)}{}

      >)>)

    }{}>)<>

  }

  # Destroy pivot letter
  <>{}<>

>)}

# Switch stack for output
<>

05AB1E, 20 17 bytes

{vð.øy¡€á€gsJ£yý

Try it online!

Explanation

With example for the first iteration of myface

{v                  # for each char y in sorted input
  ð.ø               # surround current string with spaces
                    # STACK: ' myface '
     y¡             # split at current letter
                    # STACK: [' myf', 'ce ']
       ۇ           # remove non-letters
                    # STACK: ['myf','ce']
         €g        # get the length of each string in the pair, reversed
                    # STACK: ['myf','ce'], [2,3]
            sJ      # join the pair back to a string
              £     # split into 2 pieces of the calculated sizes
                    # STACK: ['my','fce']
               yý   # join on the current char y
                    # STACK: 'myafce'

The string is surrounded with spaces each iteration as splitting on the first or last letter of the string would result in a length-1 list otherwise and the merge wouldn't include that letter.

Pyth, 18 16 19 16 bytes

VSQ=QXx_QN-QNN)Q

Try it here

Explanation

VSQ=QXx_QN-QNN)Q
VSQ           )       For each character (N) in the sorted input (Q)...
          -QN         ... remove the character from Q...
      x_QN            ... get the reflected position...
     X       N        ... insert N...
   =Q                 ... and save the result into Q.
               Q      Output the final result.

Python 3, 80 73 bytes

Thanks to Esolanging Fruit for reminding me that functions can return by modifying their argument.

lambda x:[x.insert(len(x)+~x.index(i),x.remove(i)or i)for i in sorted(x)]

Try it online!

Takes input as a list of characters.

Python 2, 70 bytes

def f(t):
 for c in sorted(t):i=t.index(c);l=len(t)+~i;t[l:l]=t.pop(i)

Try it online!

Modifies the input list

Ruby, 51 bytes

->s{s.sort.map{|c|s.insert~s.index(c),s.delete(c)}}

Try it online!

Takes an array of chars

Returns by modifying the input

Retina 0.8.2, 61 bytes

$
a
{`(.)(.*)\1$
$2$.`$*_$1$1
+`(.)_(_*.)
$2$1
}T`_l`l!`.$
!

Try it online! Link includes test cases. Explanation:

$
a

Start the loop at a.

{`(.)(.*)\1$
$2$.`$*_$1$1

If the input contains the current letter, move it to the end, with a string of _s representing its original position.

+`(.)_(_*.)
$2$1

For each _ move the letter back one character.

}T`_l`l!`.$

Increment the letter. After z change it to a ! so it doesn't match anything and the loop ends.

!

Delete the !.

Java 8, 140 96 92 88 87 85 bytes

s->{for(char c=9;++c>0;){int i=s.indexOf(c);if(i>=0)s.add(s.size()+~i,s.remove(i));}}

-44 bytes creating a port of @TFeld's Python 2 answer.
-6 bytes thanks to @OlivierGrégoire.

Modifies the input List instead of creating a new one.

Explanation:

Try it online.

s->{                     // Method with ArrayList<Character> parameter and no return-type
  for(char c=9;++c>0;){  //  Loop over all characters known
                         //  (except for the first 9 unprintables)
    int i=s.indexOf(c);  //   Index of the character, or -1 of it isn't present
    if(i>=0)             //   If the current character is present in the List
      s.add(s.size()+~i,s.remove(i));}}
                         //    Change the position of this character to index `l-i-1`,
                         //    (where `l` is the size of the input-List)

JavaScript, 85 80 79 bytes

^{-6 bytes thanks to @DanielIndie}

a=>[...a].sort().map(i=>a.splice(s=a.indexOf(i),1)&&a.splice(a.length-s,0,i))&&a

Try it online!

Red, 96 94 bytes

2 bytes saved thanks to Kevin Cruijssen

func[x][foreach c sort copy x[i:(length? x)+ 1 - index? find x c insert at replace x c""i c]x]

Try it online!

More readable:

f: func[x][
    foreach c sort copy x[                  ; for each symbol in the sorted input
       i: (length? x) + 1 - index? find x c ; find its index and reflect it 
       insert at replace x c "" i c         ; remove it by replacing it with an empty char 
                                            ; and insert the symbol at its new index   
    ]
    x                                       ; return the transformed string
]

R, 73 72 69 bytes

function(s){for(x in sort(s))s=append(s[x!=s],x,match(x,rev(s))-1);s}

Try it online!

Inputs and outputs a vector of characters.

Jelly,  12  11 bytes

W;ṢḟṁUṣ¥jʋ/

A monadic link accepting a list of characters and returning a list of characters.

Try it online!

How?

W;ṢḟṁUṣ¥jʋ/ - Link: list of characters V  e.g. "myface"  ...i.e. ['m','y','f','a','c','e']
W           - wrap V in a list                 ["myface"]
  Ṣ         - sort V                           ['a','c','e','f','m','y']
 ;          - concatenate                      ["myface",'a','c','e','f','m','y']
          / - reduce with:
         ʋ  -   last four links as a dyad:
            -   (i.e. start with "myface" on the left and 'a' on the right 
            -         2nd iteration has that result on the left and 'c' on the right
            -         and so-forth)            e.g. left = myface, right = 'a'
   ḟ        -     filter out (right from left)      "myfce"
       ¥    -     last two links as a dyad:
     U      -       upend left                      "ecafym"
      ṣ     -       split at occurrences of right   ["ec","fym"]
    ṁ       -     mould (ḟ(x,y)) like (Uṣ¥(x,y))    ["my","fce"] 
         j  -   join with right                   "myafce"

Perl 5 -p, 37 bytes

#!/usr/bin/perl -p
for$a(a..z){s/$a//&&s/.{@{-}}$/$a$&/}

Try it online!

Japt, 23 22 bytes

¬n rÈ+S kY iYJ-XbY)x}U
¬n                     // Split the input into chars and sort it.
   r                }U // Then reduce the result with initial value of the input.
    È+S                // Append a space for replacing edge cases and
        kY             // remove the current char from the string.
           iY          // Insert it back
             J-XbY     // at the calculated index,
                  )x   // and remove the unnecessary space once we're done.

Saved one byte thanks to Oliver.
Try it online!

Vyxal, 15 12 10 bytes

s(n/₌ṅtLnṀ

Thanks to @AndrovT and @TheThonnu!

Try it Online!

Haskell, 87 bytes

s#c|(h,_:t)<-span(/=c)s,(v,w)<-splitAt(length t)$h++t=v++c:w|1<2=s
f s=foldl(#)s['a'..]

Try it online!

f s=foldl(#)s['a'..]         -- fold the function '#' into all characters from 'a'
                              -- with the starting value of the input string s
s#c=                          -- in each step (s: result so far, c: next char)
   (h,_:t)<-span(/=c)s        -- let 'h' be the substring before 'c' and
                              -- 't' the substring after 'c'. the pattern match
                              -- fails if there's no 'c' in 's'
   (v,w)<-splitAt(length t)$h++t
                              -- split the string 'h++t' at index length of t
   =v++c:w                    -- return 'v' followed by 'c' followed by 'w'
   |1<2=s                     -- if there's no 'c' in 's', return 's' unchanged             

SNOBOL4 (CSNOBOL4), 132 128 bytes

	DEFINE('I(I)')
I	U =&LCASE
N	U LEN(1) . K REM . U	:F(RETURN)
	I ARB @S K	:F(N)
	I K =
	I ARB . L RPOS(S) REM . R
	I =L K R	:(N)

Try it online!

Straightforward implementation of the required algorithm. Saved a few bytes by switching to a function rather than a full program; the explanation remains the same, more or less.

	I =INPUT			;* read input
	U =&LCASE			;* alias for lowercase letters (it started out as uppercase)
N	U LEN(1) . K REM . U	:F(O)	;* set K to the next lowercase letter, and when empty, goto O
	I ARB @S K	:F(N)		;* set S to the number of letters before K, or goto N
	I K =				;* remove K
	I ARB . L RPOS(S) REM . R	;* set R to the last S characters of I and L to the others
	I =L K R	:(N)		;* recombine the string and goto N
O	OUTPUT =I			;* print new string
END

C (clang), 164 162 bytes

y,n,a,b,c,p,i;f(char*s,l){for(i=0;p=0,++i<123;p<l&&(y=s[p],n=l+~p,a=p+1,b=p,n<p&&(a=n,b=n+1),c=l+~(2*(n<p?n:p)),memmove(s+b,s+a,c),s[n]=y))while(s[p]^i&&p<l)p++;}

Try it online!

f() takes char-array containing input string and length of this array as parameters and performs required reflections in place.

callf() does pretty-printing.

Credits

-2 bytes. @Kevin. Thanks

APL+WIN, 63 bytes

Prompts for input string

l←s[⍋⎕av⍳s←,⎕]⋄⍎∊(⍴s)⍴⊂'s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l⋄l←1↓l⋄'⋄s

Explanation:

l←s[⍋⎕av⍳s←,⎕] sort characters into alphabetical order

⍎∊(⍴s)⍴⊂'....' create an implicit loop for each character

s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l do the relection for first character in l

l←1↓l drop the first character in l

s display the result

⋄ statement separator

Perl, 74 70 bytes

84 80 bytes including invocation as unix filter

for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}

$ echo -e 'dcba\nmyface\na\nacb\ncwmfjordbankglyphsvextquiz' |
> perl -pE'for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}'
dcba
fyecma
a
bac
ieabhqzugdltkfnvpjxsormycw