> It's clear you prefer the final type as suffix. That just means you need another syntax or keyword (such as "let") to introduce a variable declaration.

Not really? Assuming type and variable names are lexically distinguishable via the lexer hack or, say, capitalization. Here’s an LR(1) grammar (in Grammophone[1] syntax) with postfix types and dereferencing:

  stmt -> init ; | expr ; .
  
  init -> decl | decl = expr .
  decl -> dtor type .
  dtor -> ambi | dfun .
  dfun -> ambi ( decl ) | ambi ( darg ) | dfun ^ | dfun ( ) .
  darg -> decl , | darg decl , .
  
  expr -> summ | summ = expr .
  summ -> prod | summ + prod .
  prod -> post | prod * post .
  post -> ambi | efun .
  efun -> ambi ( expr ) | ambi ( earg ) | efun ^ | efun ( ) .
  earg -> expr , | earg expr , .

  ambi -> name | ambi ^ | ambi ( ) .

  # Stub
  type -> int .
  name -> x .

It lacks the comma operator or Go-style grouping of multiple variables before a single type, but adding either one is easy and both is possible, though in the latter case the “ambi” hack would need to be extended. I’m willing to believe you could even do this with LL(1) / recursive descent, but the grammar structure would probably end up rather horrible.

Whether this is a smart idea as far as ergonomics of syntax errors go, I don’t know.

[1] https://mdaines.github.io/grammophone/