### Description

The parsing of params in parameterized ES|QL queries appears to be inconsistent with the parsing of non-parameterized ES|QL queries. Some examples on current main:

- ```
  {"query": "row a = 1 | eval x = now() + ?", "params": [{"type":"time_duration", "value":"5 hour"}]}
  ```
  results in the following exception:
  ```
  "type":"parsing_exception","reason":"line 1:23: Cannot cast value [5 hour] of type [KEYWORD] to parameter type [TIME_DURATION]"}],"type":"parsing_exception","reason":"line 1:23: Cannot cast value [5 hour] of type [KEYWORD] to parameter type [TIME_DURATION]"
  ```
- ```
  {"query": "row a = 1 | eval x = now() + ?", "params": ["1 week"]}
  ```
  results in
  ```
  "type":"verification_exception","reason":"Found 1 problem\nline 1:22: [+] has arguments with incompatible types [DATETIME] and [KEYWORD]"
  ```
- ```
  "query": "row a = 1 | eval x = now() + ? week", "params": [1]
  ```
  results in
  ```
  "type":"parsing_exception","reason":"line 1:32: extraneous input 'week' expecting <EOF>"}],"type":"parsing_exception","reason":"line 1:32: extraneous input 'week' expecting <EOF>"
  ```

All the queries work fine if the `?` is manually substituted with the given parameter.

The first two indicate that the parsing of query parameters is not consistent with our normal parsing, type resolution and verification pipeline.

According to @astefan , `version` is affected in a similar way.

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/parser/StatementParserTests.java
private LogicalPlan processingCommand(String e) {
        return parser.createStatement("row a = 1 | " + e);
    }
    private static final LogicalPlan PROCESSING_CMD_INPUT = new Row(EMPTY, List.of(new Alias(EMPTY, "a", integer(1))));
    private static UnresolvedAttribute attribute(String name) {
        return new UnresolvedAttribute(EMPTY, name);
    }
    private static ReferenceAttribute referenceAttribute(String name, DataType type) {
        return new ReferenceAttribute(EMPTY, name, type);
    }
    private static Literal integer(int i) {
        return new Literal(EMPTY, i, DataTypes.INTEGER);
    }
    private static Literal integers(int... ints) {
        return new Literal(EMPTY, Arrays.stream(ints).boxed().toList(), DataTypes.INTEGER);
    }
    private static Literal literalLong(long i) {
        return new Literal(EMPTY, i, DataTypes.LONG);
    }
    private static Literal literalLongs(long... longs) {
        return new Literal(EMPTY, Arrays.stream(longs).boxed().toList(), DataTypes.LONG);
    }
    private static Literal literalDouble(double d) {
        return new Literal(EMPTY, d, DataTypes.DOUBLE);
    }
    private static Literal literalDoubles(double... doubles) {
        return new Literal(EMPTY, Arrays.stream(doubles).boxed().toList(), DataTypes.DOUBLE);
    }
    private static Literal literalUnsignedLong(String ulong) {
        return new Literal(EMPTY, asLongUnsigned(new BigInteger(ulong)), DataTypes.UNSIGNED_LONG);