Add Go wrappers for PL/pgSQL expression and assignment raw-parse modes

[dullkingsman]

What

Adds four small Go functions exposing raw-parse modes that already exist
as public C entry points in the vendored libpg_query, but were never
wrapped in Go:

• ParsePlPgSqlExpr / parser.ParsePlPgSqlExprToProtobuf — parses a bare
  PL/pgSQL expression fragment (a condition, a RETURN value, a RAISE
  param, etc.), using PG_QUERY_PARSE_PLPGSQL_EXPR.
• ParsePlPgSqlAssign1/2/3 / parser.ParsePlPgSqlAssign{1,2,3}ToProtobuf
  — parses a PL/pgSQL assignment statement ("target := expr") for a one-,
  two-, or three-part dotted target, using
  PG_QUERY_PARSE_PLPGSQL_ASSIGN{1,2,3}.

Both follow the exact same two-layer split as the existing Parse/
ParseToProtobuf pair. No existing function changes at all — this is a
pure addition, and no grammar, deparser, or other C source changes are
included.

Why

ParsePlPgSqlToJSON already records a parseMode on every PLpgSQL_expr
node it emits, telling you exactly which raw-parse mode PostgreSQL itself
used to compile that fragment — but there's currently no way to act on
that information. If you want to independently re-parse one of those
fragments (to canonicalize it, fingerprint it, lint it, or otherwise
analyze it apart from the rest of the function body), you're stuck: a bare
expression like a IS NULL isn't valid input to Parse (it's not a
complete statement), and an assignment fragment like n := a || b isn't
either, since := isn't SQL syntax at all outside PL/pgSQL. The C library
already solves this correctly — pg_query_parse_protobuf_opts and the
PG_QUERY_PARSE_PLPGSQL_EXPR/ASSIGN1/2/3 constants are public, stable,
and already used internally — the gap is purely that the Go bindings never
exposed them.

We ran into this concretely while trying to fix spurious diffs in a tool
that hashes PL/pgSQL function bodies for change detection: cosmetic
reformatting inside an individual expression (e.g. a||b vs a || b)
was indistinguishable from a real change, because there was no way to
re-parse and re-canonicalize that one fragment on its own. These four
functions closed that gap cleanly, using PostgreSQL's own parser modes for
the job rather than an approximation (e.g. wrapping fragments in a
synthetic SELECT).

Notes for reviewers

• PLAssignStmt (the node ParsePlPgSqlAssign1/2/3 return) has no
  deparse support anywhere in this library — that's out of scope for this
  PR. Its Val field is already an ordinary *SelectStmt, so callers
  needing to deparse the right-hand side can do so directly with the
  existing Deparse; the target (Name/Indirection) can be
  reconstructed via the library's own existing MakeColumnRefNode. Happy
  to follow up with real PLAssignStmt deparse support as a separate PR
  if that's of interest.
• Tests added in plpgsql_raw_parse_test.go cover both success and
  expected-failure cases (e.g. ParsePlPgSqlExpr correctly rejecting a
  full statement). Full existing test suite passes unchanged.