If a hex literal has an 'd' of 'f' in it, such as '0xf' or '0xd', the compiler fails with illegal tree structure.

The other hex literals work.  The issue is probably related to using `f` and `d` in float and double literals.

```
    public void testHexCollisionDouble() {
        assertEquals(13, exec("return 0xd"));
    }

    public void testHexCollisionFloat() {
        assertEquals(15, exec("return 0xf"));
    }

    public void testHex() throws Exception {
        for (int i = 0; i <= 15; i++) {
            String hex = Integer.toHexString(i);
            if ("d".equals(hex) || "f".equals(hex)) {
                continue;
            }
            assertEquals(i, exec("return 0x" + hex));
            assertEquals(i, exec("return 0x" + hex.toUpperCase(Locale.ROOT)));
            assertEquals(i, exec("return 0X" + hex));
            assertEquals(i, exec("return 0X" + hex.toUpperCase(Locale.ROOT)));
        }
    }
```
modules/lang-painless/src/main/java/org/elasticsearch/painless/phase/DefaultSemanticAnalysisPhase.java
public void visitExplicit(EExplicit userExplicitNode, SemanticScope semanticScope) {
        String canonicalTypeName = userExplicitNode.getCanonicalTypeName();
        if (semanticScope.getCondition(userExplicitNode, Write.class)) {
            throw userExplicitNode.createError(
                new IllegalArgumentException(
                    "invalid assignment: cannot assign a value to an explicit cast with target type [" + canonicalTypeName + "]"
                )
            );
        }
        if (semanticScope.getCondition(userExplicitNode, Read.class) == false) {
            throw userExplicitNode.createError(
                new IllegalArgumentException(
                    "not a statement: result not used from explicit cast with target type [" + canonicalTypeName + "]"
                )
            );
        }
        Class<?> valueType = semanticScope.getScriptScope().getPainlessLookup().canonicalTypeNameToType(canonicalTypeName);
        if (valueType == null) {
            throw userExplicitNode.createError(new IllegalArgumentException("cannot resolve type [" + canonicalTypeName + "]"));
        }
        AExpression userChildNode = userExplicitNode.getChildNode();
        semanticScope.setCondition(userChildNode, Read.class);
        semanticScope.putDecoration(userChildNode, new TargetType(valueType));
        semanticScope.setCondition(userChildNode, Explicit.class);
        checkedVisit(userChildNode, semanticScope);
        decorateWithCast(userChildNode, semanticScope);
        semanticScope.putDecoration(userExplicitNode, new ValueType(valueType));
    }
    /**
     * Visits an instanceof expression which handles both primitive and non-primitive types.