The mixture of Shell and Tcl can be a bit tricky at times. In particular, you are wanting to deliver \ into the regular expression engine in a few places, inside a here-document with an unquoted delimiter word. Fortunately, you're otherwise putting the REs inside braces, so it's just confusing and not super-confusing!

The relevant part of the bash documentation says:

Here Documents

This type of redirection instructs the shell to read input from the current source until a line containing only word (with no trailing blanks) is seen. All of the lines read up to that point are then used as the standard input for a command.

The format of here-documents is:

   <<[-]word
       here-document
   delimiter

No parameter expansion, command substitution, arithmetic expansion, or pathname expansion is performed on word. If any characters in word are quoted, the delimiter is the result of quote removal on word, and the lines in the here-document are not expanded. If word is unquoted, all lines of the here-document are subjected to parameter expansion, command substitution, and arithmetic expansion. In the latter case, the character sequence \<newline> is ignored, and \ must be used to quote the characters \, $, and `.

If the redirection operator is <<-, then all leading tab characters are stripped from input lines and the line containing delimiter. This allows here-documents within shell scripts to be indented in a natural fashion.

Because you're using the unquoted version, you want to double up the backslashes that you want the Tcl interpreter to see. In your case, that's just the ones in the regular expressions. Thus, you want this (with everything above and below unchanged, I think):

    expect {
        timeout { exit 1 }
        -re {\\m\\d{1,}(\\.\\d{1,}){3}\\M}
    }
    if { ! [regexp {192\\.[0-9]{1,3}\\.{2}[0-9]{1,3}} $expect_out(0,string)]} {
        send -h "[COMMAND B]\\r" ;
    }

Oh, and you also need \\r (as above) throughout your script instead of \r.

I think it would be easier to split your script into two files, one which is just Bash code and the other which is just Tcl code, at least while you're developing it. Then you'd be able to make things work without having to fuss around with many layers of quoting. (The things you're substituting in now could instead be passed over as arguments to the script.)

When packaging everything back together, bash's printf %q may be helpful. It'll generate something hard to read, but it is a packaging operation after all…

And in relation to the error codes? The problem there is simpler; the test itself — [[ $? -eq 0 ]] — sets the error code. You have to save it to a proper variable and then test against that.

Here, check these boiled down cases:

bash-3.2$ ( exit 2 ); if [[ $? -eq 0 ]]; then echo ok; elif [[ $? -eq 2 ]]; then echo good; else echo bad; fi
bad
bash-3.2$ ( exit 2 ); echo $?; if [[ $? -eq 0 ]]; then echo ok; elif [[ $? -eq 2 ]]; then echo good; else echo bad; fi
2
ok
bash-3.2$ ( exit 2 ); code=$?; echo $code; if [[ $code -eq 0 ]]; then echo ok; elif [[ $code -eq 2 ]]; then echo good; else echo bad; fi
2
good

The first one is approximately what you're doing right now, the second shows just how non-obvious it can get — the intervening echo changes the result — and the third shows how to deal with it (storing the value in code here, but the name isn't really all that special).