Google Sheets, 225 bytes

=let(x,split(text(A1,"#,000"),","),join(,map(sequence(count(x)),lambda(i,let(p,text(index(x,i),"000"),r,right(p),y,if(or(mod(p,100)<20,-r=0),p,left(p)&r&mid(p,2,1)),ifs(left(y)="1",0&right(y,2),i+y=2,n(A1=1),i=1,--y,1,y))))))

Simple implementation of the algorithm in the question. Expects a number and returns a string.

Prettified:

=let(
  x, split(text(A1, "#,000"), ","),
  join(, map(sequence(count(x)), lambda(i, let(
    p, text(index(x, i), "000"),
    r, right(p),
    y, if(or(mod(p, 100) < 20, -r = 0), 
      p, 
      left(p) & r & mid(p, 2, 1)
    ),
    ifs(
      left(y) = "1", 0 & right(y, 2), 
      i + y = 2, n(A1 = 1),
      i = 1, --y,
      1, y
    )
  ))))
)

Jelly, 30 bytes

Ṛs3UṚµṫ-t0Ḍ>19‘œ?LḂ_Ɗḣ1aƲ)ƲḊ¡F

A monadic Link that accepts the number as a list of integers - its base ten digits - and yields a list of integers.

Try it online! Or see the test-suite.

How?

Ṛs3UṚµṫ-t0Ḍ>19‘œ?LḂ_Ɗḣ1aƲ)ƲḊ¡F - Link: list of integers, N
Ṛ                              - reverse {N}
                            ¡  - if...
                           Ḋ   - ...condition: dequeue (i.e. if length(N) > 1)
                          Ʋ    - ...then: last four links as a monad - f(reversed N):
 s3                            -   split into chunks of three, or fewer
   U                           -   reverse each
    Ṛ                          -   reverse - e.g. N = [1,2,3,4,5] -> Parts = [[1,2],[3,4,5]]
     µ                   )     -   for each Part:
      ṫ-                       -     tail from 1-index -1
                                       -> last, up to two digits of the part
        to                     -     trim zeros from each side
          Ḍ>19                 -     is that, converted from base ten, greater than 19?
              ‘                -     increment -> P = 2 if so, otherwise P = 1
                        Ʋ      -     last four links as a monad - f(Part):
                    Ɗ          -       last three links as a monad - f(Part):
                 L             -         length {Part}
                  Ḃ            -         is odd?
                   _           -         subtract {Part} (vectorsises)
                     ḣ         -         head to 1-index...
                      1        -         ...one -> [length is odd - first digit of Part]
                       a       -         logical AND {Part}
                                           Note: [x] AND [a, b, c] -> [(x AND a), b, c]
                                            and: all numbers are truthy except zero
               œ?              -     get the {P}th permutation of {that altered Part}
                                       (swap the last two digits if P = 2)
                          F    - flatten

Charcoal, 35 bytes

⮌⭆⪪⮌Ｓ³⭆ι∧∧∨¬κ⊖⮌ι⁻⊗λμ⎇⬤…ι²›Ｉνξ§ι⁻¹μλ

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

    Ｓ                               First input as a string
   ⮌                                Reversed
  ⪪                                 Split into groups of length
     ³                              Literal integer `3`
 ⭆                                  Map over groups and join
       ι                            Current group
      ⭆                             Map over digits and join
            κ                       Group index
           ¬                        Is zero
          ∨                         Logical Or
               ι                    Current group
              ⮌                     Unreversed
             ⊖                      Is not one
         ∧                          Logical And
                  λ                 Current digit
                 ⊗                  Doubled
                ⁻                   Does not equal
                   μ                Digit index
        ∧                           Logical And
                       ι            Current group
                      …             Truncated to length
                        ²           Literal integer `2`
                     ⬤              All digits satisfy
                           ν        Innermost digit
                          Ｉ         Cast to integer
                         ›          Is greater than
                            ξ       Innermost index
                    ⎇               If true then
                              ι     Current group
                             §      Cyclically indexed by
                                ¹   Literal integer `1`
                               ⁻    Subtract
                                 μ  Digit index
                                  λ Else current digit
⮌                                  Unreversed
                                   Implicitly print

Some byte savings were obtained:

• by zeroing out all of the digits of the groups 1 and 001, not just the last
• by zeroing out the last digit of groups ending in 0
• by reversing groups that are single digits 2 to 9 (they get multiplied by 11, reversed, then divided by 11 again).

R, 99 98 94 bytes

\(n,`[`=gsub)"([^01])([^0])(?=(...)*$)"["\\2\\1","(^1(?=.)|1(..))(?=(...)*$)"["0\\2",n,,T],,T]

Attempt This Online!

^{-4 bytes by pajonk.}

\(n,`?`=\(x)paste(x,collapse=""),`~`=strsplit,`-`=nchar){r=?rev(el(n~""))
L=-r
o={}
for(i in seq(1,L,3)){g=substring(r,i,e<-min(i+2,L))
s=el(g~"")
n=-g
if(n<2&s[1]<2&L>1|n>2&s[3]<2)s[max(1,n)]="0"
if(n>1&!grepl("^.[01]|^0",g))s[1:2]=s[2:1]
o=c(o,s)}
?rev(o)}

Perl 5 -p, 73 69 bytes

s/((^1\B)|(1(..)))(?=(...)*$)/0$4/g;s/([^01])([^0])(?=(...)*$)/$2$1/g

Try it online!

JavaScript (ES6), 74 bytes

Expects a string. Returns another string.

s=>s.replace(/1(?=..(...)*$)|(^1\B|[2-9][^0])(?=(...)*$)/g,s=>s[1]+s[0]|0)

Try it online!

Try the first 100 values

Method

We look for:

• 1(?=..(...)*$) → a 1 followed by two digits, followed by any number of 3-digit groups until the end of the string
• ^1\B(?=(...)*$) → a 1 at the beginning of the string, not immediately followed by the end of the string, followed by any number of 3-digit groups until the end of the string ⁽¹⁾
• [2-9][^0](?=(...)*$) → a digit in the range 2-9, followed by a digit in the range 1-9, followed by any number of 3-digit groups until the end of the string

We replace each match s with s[1] + s[0] | 0, which results in:

• 0 if the match is 1 (because this yields "undefined1" | 0, which evaluates to 0)
• otherwise, the reversed two-digit number (which is guaranteed to be coerced back into a two-digit string, since it cannot start with a zero)

_{(1) This could obviously be more simply described as ^1(?=(...)+$), but then the pattern (?=(...)*$) could not be factorized with the next case in the final regular expression.}

Worked example

.-----------> ^1(...)(...)(...)$ replaced with 0
|.----------> 1(..)(...)(...)$ replaced with 0
||   .------> 34(...)$ replaced with 43
||   |  .---> 45$ replaced with 54
||   |_ |_
1100234345 -> 0000243354

Retina, 45 bytes

r`..?.?
$&,
V`[2-9][1-9]\b
\b1(?=..,|,.)
0
,

Try it online!

• r`..?.?: Match chunks of 1 to 3 digits, using r to enable right-to-left mode.
  $&,: Replace each match with itself followed by a comma.
• V`[2-9][1-9]\b: Match a ≥2 digit followed by a ≥1 digit ending a chunk (using a word boundary: digits are word characters and commas are non-word characters). Stage type V reverses each match.
• \b1(?=..,|,.): Match a 1 at the start of a chunk if it is followed by something matching .., (making it a 3-digit chunk) or matching ,. (making it a 1-digit chunk that is not the last chunk). Replace it with 0.
• Finally, match , and replace it with an empty string.

Retina, 53 bytes, follows rule 4

r`..?.?
$&,
V`[2-9][1-9]\b
(?<=00|\b)1(?=..,|,.)
0
,

Try it online!

Mostly the same as before; the third regex uses a lookbehind to also match the 1 in 001.