If you have Office 365 Excel then use This array formula:

=TEXTJOIN(",",,TRIM(MID(SUBSTITUTE(A2,",",REPT(" ",99)),((LEN(A2)-LEN(SUBSTITUTE(A2,",",""))+1)-ROW(1:INDEX(XFD:XFD,LEN(A2)-LEN(SUBSTITUTE(A2,",",""))+1)))*99+1,99)))

Being an array formula it needs to be confirmed with Ctrl-Shift-Enter instead of Enter when exiting edit mode.

If one does not have Office 365 Excel then vba will probably be the only choice.

Check an efficient method without XML:

select *, (select string_agg(value, ',') within group (order by ordinal desc) from string_split(COLUMN1, ',', 1)) as RESULT
from @TBL

Via regex:

:s/\v([^, ]+)(\s*,\s*)([^, ]+)/\3\2\1/

If you do it often you can make a map out of it, e.g.:

:nmap <F5> :s/\v([^, ]+)(\s*,\s*)([^, ]+)/\3\2\1/<CR>

Put the cursor on the line you want to flip and hit F5.

Here I do it with sed:

sed '/,/!b                                                   
s/\( *[^ ]*\)\(.*\)/\2,\n\1/;:t
s/\([^,]*,\)\(\n.*\)/\2\1/;tt
s/\n\(.*\),/\1/' <<\DATA
LABEL1
    .BYTE 01, 02, 03, 04, 05
    .BYTE 01, 02, 03        
LABEL1
    .BYTE 01, 02, 03, 04, 05
    .BYTE 01, 02, 03
DATA

OUTPUT

LABEL1
    .BYTE 05, 04, 03, 02, 01 
    .BYTE 03, 02, 01 
LABEL1
    .BYTE 05, 04, 03, 02, 01 
    .BYTE 03, 02, 01 

It checks for a comma on the current line. If there is !no comma, sed branches out of the script and autoprints the line. If the line does contain a comma sed does the following:

1. It first prepares the line by s///ubstituting the following:
   • \( *[^ ]*\) - the first occurring sequence of zero or more spaces followed immediately by a sequence of zero or more not space characters referenced as \1 followed immediately by...
   • \(.*\) - everything else on the line referenced as \2...
   • ...with \2,\n\1
   • Note - using the \n escape in the right-hand s///ubstitution field like this is not fully portable. For a sed that does not support it, it can be done instead by substituting a literal newline for the n in the statement.
2. It :defines a branch/test label called t.
3. While it still can, sed s///ubstitutes:
   • \([^,]*,\) - A sequence of zero or more not comma characters then a single comma referenced as \1 followed immediately by...
   • \(\n.*\) - A sequence beginning with at least one \newline character followed by anything/everything remaining in pattern space referenced as \2...
   • ...with \2\1.
4. If the previous s///ubstitution tests successful, sed branches back to the :test label and tries again.
5. Last sed does a little cleanup and replaces:
   • \n\(.*\), - the first occurring \newline character and the last occurring comma...
   • \1 - ...with all that lies between.

As sed does the recursive replacement, the \newline delimiter walks backwards one comma-delimited field at a time. It stops the replacements when the \newline is the first character on the line. Here's a look at its progress through the recursive replacement process:

 01, 02, 03, 04, 05,\n    .BYTE$
 01, 02, 03, 04,\n    .BYTE 05,$
 01, 02, 03,\n    .BYTE 05, 04,$
 01, 02,\n    .BYTE 05, 04, 03,$
 01,\n    .BYTE 05, 04, 03, 02,$
\n    .BYTE 05, 04, 03, 02, 01,$

After its initial preparatory substitution, sed does not delimit on anything but commas and the inserted \newline character. So any kind of comma-separated values work fine. Here's the output from running your long bit through it:

ITINERARY_ARRAY_01
    .BYTE <ITINERARY_00A
    .BYTE <ITINERARY_01A
    .BYTE <ITINERARY_02A
    .BYTE <ITINERARY_03A
    .BYTE <ITINERARY_04A
    .BYTE <ITINERARY_05A
    .BYTE <ITINERARY_06A
    .BYTE <ITINERARY_07A
    .BYTE <ITINERARY_08A
    .BYTE <ITINERARY_09A
    .BYTE <ITINERARY_10A
    .BYTE <ITINERARY_11A
    .BYTE <ITINERARY_12A
    .BYTE <ITINERARY_13A
    .BYTE <ITINERARY_14A
;-------------------
ITINERARY_01E
    .BYTE $00, $07, $05, $03 
;-------------------
ITINERARY_01F
    .BYTE $00, $09, $07, $05, $03 
;-------------------
ITINERARY_01G
    .BYTE $00, $0D, $28 
;-------------------
ITINERARY_01H
    .BYTE $00, $13, $0F, $0D, $28 
;-------------------
ITINERARY_01I
    .BYTE $00, $11, $0F, $0D, $28 
;-------------------
ITINERARY_01J
    .BYTE $00, $1E, $20, $09, $07, $05, $03 
;-------------------
ITINERARY_01K
    .BYTE $00, $15, $13, $0F, $0D, $28 
;-------------------
ITINERARY_01L
    .BYTE $27, $1C, $1E, $20, $09, $07, $05, $03
    .BYTE $00
;---------------------

You can do this with awk:

#!/bin/bash

awk 'BEGIN{FS=",[ ]*"; OFS=", "}
    {
        for (i=NF; i>0; i--) {
            printf "%s", $i;
            if (i>1) {
                printf "%s", OFS;
            }
        }
        printf "\n"
    }'

Explanation of the script:

• FS=",[ ]*";: The regex for Field Separator (delimiter for your input) matches a comma followed by zero or more spaces, so your input can be any of:
  • a, b, c, 1337, d, e
  • a,b,c,1337,d,e
  • a, (many spaces) b, c,1337,d, e
• OFS=", ": The Output Field Separator (delimiter for your output) will be explicitly a comma followed by a space (so output looks consistent)
• for (i=NF; i>0; i--) { ... }: NF means the Number of Fields in the current line. Here we iterate backwards, printing from the last field to the first field.
• if (i>1) { ... }: Only print the OFS if it's not the last field in the output
• printf "\n": new line.

Sample usage:

$ ./script_name < input_file > output_file