You found a bug in my code. The replacement rule for the SequencePattern should be

SequencePattern -> "[]"

As for the rest, you can't compare IsExpression directly with SyntaxQ, because IsExpression is intended to work only on full form expressions. That was per your guidance:

I am not interested in syntactic sugar I want an emulator that is as close to symbols, square brackets, and commas as possible

SyntaxQ is vastly more comprehensive. You'll notice that things like SyntaxQ["s[]s"] return True, because there is a front end "helper" in the parsing that assumes that there was intended to be a space, s[] s, which gets parsed to (i.e. is syntactic sugar for) Times[s,s[]]. Sander and I both made the point that to replicate the parsing of all the tokens and patterns recognized by the front end would be a massive undertaking.

I should have remarked that there are some obvious things this doesn't capture. For example, it assumes symbol names are only alpha characters. My qualifier around not being complete or correct was leaving the door open for overlooked patterns, not nitty-gritty details. Having said that, I'm not overlooking Null--instead I'm assuming that any Null is provided explicitly.

Here's something that "emulates" SyntaxQ. I've named it IsExpression. It works by recursively identifying legal sub-expressions and sequences. Since you're not interested in syntactic sugar, it assumes full form expressions. I am not confident that this is complete or correct for all cases, but maybe it's a sufficiently decent approximation.

ReduceExpressionStep[token_String][exp_String] :=
  With[
   {NumberPattern = 
     RegularExpression["(\\d+\\.\\d+)|(\\d+\\.)|(\\.\\d+)|(\\d+)"],
    StringPattern = RegularExpression["\"[^\"]\""],
    SymbolPattern = RegularExpression["[[:alpha:]]+"],
    HeadedPattern = "$[]",
    SequencePattern = RegularExpression["\\[(\\$,)*\\$\\]"]},
   StringReplace[
    StringDelete[exp, Whitespace],
    {NumberPattern -> token,
     StringPattern -> token,
     SymbolPattern -> token,
     HeadedPattern -> token,
     SequencePattern -> ""}]];
ReduceExpression[token_String][exp_String] := 
  FixedPoint[ReduceExpressionStep[token], exp];
IsExpression[exp_String] := "$" == ReduceExpression["$"][exp]

I am not interested in syntactic sugar I want an emulator that is as close to symbols, square brackets, and commas as possible, and contains only Mathematica functions that cannot be expressed in terms of simpler Mathematica functions. I hope to send in an example that is not super trivial. A stupid example would be an emulator that returns False for every input string, which would be the correct answer much more than half the time.