PowerShell, 262 155 151 127 125 95 bytes

$args|sort{"rlyegwbrscbrocpyrvo lvnfaldgccvmacmcvseraolsrygpptwkpnoeb".indexof((-join$_[3,0]))}

Try it online!

Naive approach. PowerShell sort-object can sort based on a script block that gets executed for every object. Here we're simply getting the .IndexOf() the color from a string, which will assign a numerical value to each color, and then sorts based on those numbers. The string is constructed from the fourth and first letters of each color to ensure uniqueness. Output is implicit.

-4 bytes thanks to Shaggy.
-2 bytes thanks to mazzy.
A whopping -30 bytes thanks to KGlasier.

JavaScript (SpiderMonkey),  106 105  104 bytes

"When in doubt, just hash the bloody input."

a=>a.sort((a,b)=>(g=s=>'i0008bar5dj60007f3001p09mseqg0hk40cnl2o'[parseInt(s,36)*50%257%170%40])(a)>g(b))

Try it online!

Jelly, 28 bytes

“½Ṗ©cƘʂẒẹMMỤẓHP’Œ?“ðÑþQ’,ḥµÞ

Try it online!

How it works

µ turns everything to its left into a monadic chain, which Þ maps over the input array and sorts the input according to the generated values.

“½Ṗ©cƘʂẒẹMMỤẓHP’ sets the return value to 176073885534954276199526358143331.

Œ? generates the 176073885534954276199526358143331^th permutation of the positive integers (without the sorted tail), yielding $small[20,28,15,3,5,26,18,16,8,30,4,25,2,21,22,11,24,1,23,10,29,12,17,27,14,9,6,13,7,19]$.

“ðÑþQ’ yields 391695582; , prepends it to the permutation. Then, ḥc ompute Jelly's 391695582^th hash function, mapping the
resulting buckets to the integers of the permutation.

The magic constant 391695582 was found by Jelly's utils.

dennis-home:utils$ time ./findhash 30 29 <<< '["red","yellow","green","brown","scarlet","black","ochre","peach","ruby","olive","violet","fawn","lilac","gold","chocolate","mauve","cream","crimson","silver","rose","azure","lemon","russet","grey","purple","white","pink","orange","blue"]'

391695582



real    0m2.058s

user    0m15.077s

sys     0m0.023s

Python 3, 93 bytes

lambda r:sorted(r,key=lambda s:'iV^ZzwnFM@pYuOobXGAKyf[tUR]E'.find(chr(int(s,36)%127%60+64)))

Try it online!

Reads each color as a base-36 int. Brute-forced the moduli and chose an arbitrary offset among the 19 that didn't require escapes.

I will improve the string compression in a while

Japt, 88 78 71 bytes

ñ@`䊐âwrÒ.cÖ¨acru½ivo¤faØngoÒqauvœamsolv€osz¨e¶s gœrpl–tpˆ„g½u`bXé4 ¯3

Try it online!

Wolfram Language 255 213 199 bytes

Fourteen bytes saved by Dennis, who avoided the " marks, using symbols instead of strings.

SortBy[#,{yellow,green,brown,scarlet,black,ochre,peach,ruby,olive,violet,fawn,lilac,gold,chocolate,mauve,cream,crimson,silver,rose,azure,lemon,russet,grey,purple,white,pink,orange,blue}~Position~#&]&

Try It Online!

Powershell, 124 120 124 119 118 102 bytes

$args|sort{$c=$_

'bluOrPiWPuG*yRusLeARoSiCriCrMCGoLFVOlRuPOBlSBGYR'-csplit'(?=[A-Z])'|%{$c-like"$_*"}}

Try It Online!

Explanation:

1. The data string contains the first significant letters of the color labels in descending order. Except for the Grey label - G*y is shorter.




2. -csplit'(?=[A-Z])' splits the data string to the array (blu,Or,Pi,W,Pu,G*y,Rus,Le,A,Ro,Si,Cri,Cr,M,C,Go,L,F,V,Ol,Ru,P,O,Bl,S,B,G,Y,R)




3. |%{$c-like"$_*"} maps the string array to the array of boolean. Where True means "a color label starts from this string" (like is case-insensitive operator, csplit - case-sensitive. see doc).




4. sort{} sorts a color lables by the arrays of boolean in ascending order.

The sorting by array is a very interesting feature in the Powershell. In this script all arrays have the same length and contain Boolean values only. This sorting is performed in the lexographic order of boolean arrays.

Therefore, the string can contain one-letter abbreviations for the last labels. If there is a match at the beginning of the array, the matches at the end have no effect.

       blu Or Pi W Pu G*y Rus Le A Ro Si Cri Cr M C Go L F V Ol Ru P O Bl S B G Y R

green: -   -  -  - -  -   -   -  - -  -  -   -  - - -  - - - -  -  - - -  - - T - -

gold : -   -  -  - -  -   -   -  - -  -  -   -  - - T  - - - -  -  - - -  - - T - -

grey : -   -  -  - -  T   -   -  - -  -  -   -  - - -  - - - -  -  - - -  - - T - -



     : green < gold < grey

Where T is true and - is false.

Test script:

$f = {



$args|sort{$c=$_

'bluOrPiWPuG*yRusLeARoSiCriCrMCGoLFVOlRuPOBlSBGYR'-csplit'(?=[A-Z])'|%{$c-like"$_*"}}



}



@(

    ,( @(), @() )

    ,( ('green', 'blue', 'red', 'brown'), ('red', 'green', 'brown', 'blue') )

    ,( ("gold", "grey", "green"), ("green", "gold", "grey") )

    ,( ("ruby","yellow","red","grey"), ("red", "yellow", "ruby", "grey") )

    ,( ("gold", "green", "fawn", "white", "azure", "rose", "black", "purple", "orange", "silver", "ruby", "blue", "lilac", "crimson", "pink", "cream", "lemon", "russet", "grey", "olive", "violet", "mauve", "chocolate", "yellow", "peach", "brown", "ochre", "scarlet", "red"),

       ("red", "yellow", "green", "brown", "scarlet", "black", "ochre", "peach", "ruby", "olive", "violet", "fawn", "lilac", "gold", "chocolate", "mauve", "cream", "crimson", "silver", "rose", "azure", "lemon", "russet", "grey", "purple", "white", "pink", "orange", "blue") )

) | % {

    $inp,$expected = $_

    $result = &$f @inp  # splatting

    "$("$result"-eq"$expected"): $result"

}

Output:

True:

True: red green brown blue

True: green gold grey

True: red yellow ruby grey

True: red yellow green brown scarlet black ochre peach ruby olive violet fawn lilac gold chocolate mauve cream crimson silver rose azure lemon

russet grey purple white pink orange blue

Python 2, 186 bytes

lambda a:[y for x,y in sorted((max(" y gree br sc bla oc pe rub ol v f li go ch m cre cri si ro a le rus grey pu w pi or blu ".find(" %s "%c[:i+1])for i,j in enumerate(c)),c)for c in a)]

Try it online!

Finds all matches for progressive character substrings (Ex: "green" will check for "g", "gr", "gre", "gree", and "green") in the identifier string, and keeps the maximum index. "red" is always first, anf find() returns -1 for missing matches, so there is no identifier for red specifically.

Once the colors are turned into (index, color) pairs, sorts array on first item of pair and then discards first item of each pair.

C# (Visual C# Interactive Compiler), 321 219 210 161 159 138 bytes

n=>n.OrderBy(a=>a!="grey"?"yelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):65)

Try it online!

-3 bytes thanks to Shaggy, -18 thanks to TheLethalCoder

Takes input as a List<string>, returns an IOrderedEnumerable<string>

How this works is that it orders the list by each string's index in the original string. The original string has every color except for grey turned to it's first three letters. Grey is not there, since green and grey would cause ambiguity. Red isn't there either, since IndexOf returns -1 if the string doesn't appear.

Python 3, 130 bytes

lambda*a:sorted(a,key=lambda c:("r,ylgebwsrtbcorpcryovvlfnlagdccamvca cmnsvrearlorsgyppwtpkonbe".find(c[::3]+" "*(c=="cream")),c))

Try it online!

Charcoal, 69 68 63 56 bytes

Ｆ⪪”E$↥l∧_∧K⁰ＲY⸿h⊕ψVG⌕gbＷ⟧⁼″5/²H✳<◨Ａ³?ω↗⊘‴⭆1”²Φθ№κ⎇Σιlilι

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

Ｆ⪪”E$↥l∧_∧K⁰ＲY⸿h⊕ψVG⌕gbＷ⟧⁼″5/²H✳<◨Ａ³?ω↗⊘‴⭆1”²

Take the compressed string edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorlu and loop over each substring of length 2.

Φθ№κ⎇Σιlilι

For each substring print those input strings that contain that substring, unless the substring is 99, in which case look for lil instead. (lilac is the only colour that does not have a unique two-letter substring; olive includes li; silver includes il and black includes lac. fawn and azure can be detected using just a single letter, but that doesn't help here.)

Pyth, 66 bytes

oxc."ayÇæ£ðÐ¥~@iF[2BÍÐ:Yë)^ksTTã"2s@LN,03

Try it online here, or verify all the test cases at once here.

The colours in the list can be uniquely identified by taking the characters at index 0 and 3, assuming modular indexing. This results in the following mapping:

rr -> red

yl -> yellow

ge -> green

bw -> brown

sr -> scarlet

bc -> black

or -> ochre

pc -> peach

ry -> ruby

ov -> olive

vl -> violet

fn -> fawn

la -> lilac

gd -> gold

cc -> chocolate

mv -> mauve

ca -> cream

cm -> crimson

sv -> silver

re -> rose

ar -> azure

lo -> lemon

rs -> russet

gy -> grey

pp -> purple

wt -> white

pk -> pink

on -> orange

be -> blue

Full explanation:

oxc."..."2s@LN,03Q   Implicit: Q=eval(input())

                     Trailing Q inferred, dictionary string replaced with ... for brevity

o                Q   Order the elements of Q, as N, using:

              ,03      [0,3]

           @LN         Get the characters at the above indices in N

          s            Concatenate into a string

                         The above is result {1}

   ."..."              The compressed dictionary string

  c      2             Split into chunks of length 2

 x                     Get the index of {1} in the above

                       Implicit print of sorted list

05AB1E, 48 bytes

Σ.•Aå₂мÕh∊þèmvƶkΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•2ôy¬s3è«k

Same solution as most other answers. Will try to golf it down from here later.

Try it online or verify all test cases.

Explanation:

Σ          # Sort the (implicit) input-list by:

 .•Aå₂мÕh∊þèmvƶkΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•

           #  Push compressed string "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe"

  2ô       #  Split into parts of size 2

 y         #  Push the current string of the list we're sorting

  ¬        #  Push its head (without popping)

   s       #  Swap so the string is at the top of the stack again

    3è     #  Get the character at index 3 (with automatic wraparound)

      «    #  Merge both characters together

       k   #  And get the index in the compressed string to sort on

See this 05AB1E tip (section How to compress strings not part of the dictionary?) to understand how .•Aå₂мÕh∊þèmvƶkΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-• is "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe".