05AB1E, 66 bytes

gÍF3£D¬gÍFε3£}`R«ćªćU«X.Sγ€Ù˜ÐнsθQsʒ0Ê}©gs-4Q®ü‚€OÄO0Q&ˆ€¦}\¦D}¯O

I'm 100% sure that I can reduce some bytes here, working on it :) Meanwhile, I'll post this basic idea.

Explenation:

gÍF3£D¬gÍFε3£}`R«ćªćU«X.Sγ€Ù˜ÐнsθQsʒ0Ê}©gs-4Q®ü‚€OÄO0Q&ˆ€¦D}\¦}¯O
              `R«ćªćU«X.Sγ€Ù˜ÐнsθQsʒ0Ê}©gs-4Q®ü‚€OÄO0Q&ˆ                 Expects a 3x3 matrix. We will run this part for each relevant cell in the overall matrix.
                                                                         Pushes 1 to the global array when this cell is order-2 saddle point, pushes 0 otherwise.
                                                                         ----------
gÍ                                                                       number of rows in the matrix minus 2.
  F                                                            }         Loop Rows-2 times
   3£                                                                    Take 3 first rows.
     D¬                                                                  Push itself and the first element (first line)
       gÍ                                                                Size. (number of columns)
         F                                                 }             Loop Cols-2
          ε3£}                                                           Trim first 3 elements from each of the selected 3 rows.
                                                        €¦D              Remove the first element of each row and duplicate it for the next iteration.
                                                            \¦          Clear remaining elements on stack, remove current first row of the 3 rows, prepare for next iteration.
                                                                         ----------
              `                                                          Push the 3x3 matrix we got from the nested loop in 3 separate values to the stack. Last row on top.
               R                                                         Reverse last row.
                «                                                        Merge with the second row.
                 ćª                                                      Extract head and append
                   ćU                                                    Extract head and save in X
                     «                                                   Merge with the first row. Now all values of the cell are in order clockwise.
                      X.S                                                For each element in the list, put -1 if lower than X (middle of cell), 0 if equal, 1 if greater.
                         γ                                               Split a into chunks of equal adjacent elements. (segment)
                          €Ù˜                                            Uniquify each element and flat the list.
                             Ð                                           Triplicate
                              нsθQ                                       Extract head, extract tail, are they equal? 
                                  sʒ0Ê}©                                 Filter (remove zeros from the list), save the filtered list in register C
                                        g                                Size of the filtered list.
                                         s-                              Size of the filtered list - [1 if head was equal to the tail]
                                           4Q                            Is it equal to 4 (segments)? {{Condition I}}
                                             ®ü‚                         Overlapping pairs
                                                €O                       Sum each pair (desired: [-1,1] or [1,-1] will give 0)
                                                  Ä                      Abs(a)
                                                   O0Q                   Is the sum of all sums of pairs equals 0? (which means there was alternating 1/-1) {{Condition II}}
                                                      &                  Does both of the conditions were okay?
                                                       ˆ                 Push the result to the global array.
                                                                         ----------
                                                                ¯O       Push the global array and sum its values to get the number of order-2 saddle points. 

Try it online!

APL (Dyalog Unicode), 70 66 bytes

D←⊢-1∘⌽
+/,{16=×/|D⍵/⍨×⍵×D⍵}¨(⍉1↓⌽)⍣4×(⊢-{⊂(,⍵)[8(-,⊢)3,⍳3]}⌺3 3)⎕

Try it online!

-4 bytes thanks to @Bubbler and @ngn

Full program that requires ⎕IO←0

⍝ Helper function D: cyclic differences of a list
D←⊢-1∘⌽
  ⊢     ⍝ Each element
   -    ⍝ Subtract
    1∘⌽ ⍝ The one after
⍝ Main code
+/,{16=×/|D⍵/⍨×⍵×D⍵}¨¯2 ¯2↓1⊖1⌽×(⊢-{⊂(,⍵)[6 9 8 7 4,⍳3]}⌺3 3)⎕
⎕           ⍝ The input grid
{...}⌺3 3   ⍝ For the 3×3 window centered on each cell:
 (,⍵)[8(-,⊢)3,⍳3] ⍝ Obtain the cycle elements clockwise from the right
 ⊂                ⍝ Ensure that the output is the same shape as G
×⊢-         ⍝ The sign of the difference between each cycle and its center in G
(⍉1↓⌽)⍣4    ⍝ Trim off the entries with centers on an edge/corner
{...}¨      ⍝ For each sign-difference cycle:
 ×⍵×D⍵      ⍝ The indices where a +/- segment ends
              ⍝ (nonzero and different from the following element)
 ⍵/⍨        ⍝ The signs of each segment in order
              ⍝ (must be ¯1 1 ¯1 1 or reverse to be truthy --- can only have entries +/- 1)
 D          ⍝ Cyclic differences (must be 2 ¯2 2 ¯2 or reverse to be truthy --- can only have entries ¯2, 0, or 2)
 16=×/      ⍝ Test if product is 16: ensures right length and right values.
            ⍝ Note that the sum of the cyclic differences are always 0, so 2 2 2 2 is impossible)
+/,         ⍝ Count the total number that meet the condition

A creative idea I had was taking 2×2 stencils of 2×2 stencils with ({⊂⍵}⌺2 2)⍣2⊢G then extracting cycles with {1⌷⊃,/0 1 2 3{⍉∘⌽⍣⍺⊢⍵}¨,⍵}¨. This might have been shorter (if golfed a bit more) because it didn't initially require ¯2 ¯2↓1⊖1, but unfortunately we still had to subtract corresponding elements of G.

Ruby, 237 218 207 bytes

->a,z=0,i=j=1{l=z+=1if[[*a[i-1][h=j-1,3],(x=a[i])[j+1],*a[i+1][h,3].reverse,x[h]].map{|n|l=n<=>x[j]}.drop_while{|i|i==l}.map{|b|b==l||(l=b)==0?5:l}-[5]]-[[1,-1]*2,[-1,1]*2]==[];x[1+j+=1]||a[1+i+=j=1]?redo:z}

Try it online!

Python 2, 254 bytes

lambda m:sum(s(m[i][j:j+3],m[i+1][j:j+3],m[i+2][j+2::-1][:3])for j in range(len(m[0])-2)for i in range(len(m)-2))
t=['-','+']*2
def s(q,(x,m,y),w):a=''.join(' -+'[cmp(m,v)]for v in q+[y]+w+[x]);return[v for v,_ in zip(a,a[-1:]+a)if' '!=v!=_]in(t,t[::-1])

Try it online!

JavaScript (ES6), 179 bytes

a=>a.map((r,y)=>r.map((v,x)=>t+=x*y/r[x+1]&&a[y+1]?[...(S='12221000')+S].map((n,i)=>p-(p=d=Math.sign(v-a[y+~-n][x+~-S[i+2&7]]))&&d?s&s!=-(s=d)?T=a:T++:0,T=s=p=0)|T>>1==4:0),t=0)|t

Try it online!

How?

We iterate on each cell $v_{y,x}$ of each row $r_y$ of the input matrix.

We first make sure that we're not located over an edge of the matrix with:

x * y / r[x + 1] && a[y + 1]

(neither $x$ or $y$ is $0$ and both $v_{y,x+1}$ and $r_{y+1}$ are defined)

We iterate twice on each neighbor cell and keep track of the number of valid segments in $T$. By doing this, each segment is guaranteed to be counted twice, except the first one which may be counted either twice or three times, depending on its starting point in relation to the starting point of the cycle. Either way, we have $lfloor{T/2}rfloor=4$ for order-2 saddle points, in which case we increment the counter $t$.

Example:

If the first segment is aligned with the starting point:

neighbor cells: AAAABCCD --> AAAABCCDAAAABCCD
                             ^   ^^ ^^   ^^ ^  --> T = 8

If it is not aligned:

neighbor cells: AABCCDAA --> AABCCDAAAABCCDAA
                             ^ ^^ ^^   ^^ ^^   --> T = 9

We iterate on neighbor cells by starting with the rightmost one and moving clockwise with:

[...(S = '12221000') + S].map((n, i) => a[x + ~-n][y + ~-S[i + 2 & 7]])

Try it online!

We store the sign of the difference between the current cell and its current neighbor in $d$. We keep track of the previous value of $d$ in $p$ and the previous sign (for non-zero values) in $s$.

The logic to update $p$, $s$ and $T$ reads as follows:

p - (p = d) && d ? s & s != -(s = d) ? T = a : T++ : 0

In plain English:

• Ignore identical consecutive values.
• Ignore segments with $d=0$.
• Increment $T$ on valid sign transitions.
• Whenever an invalid sign transition is detected, do T = a to force all upcoming operations on $T$ to either NaN or $0$, thus invalidating the final test.