Parser correctly parses glyph classes in rules, but not single glyphs

[simoncozens]

Given:

@test = [ a b ];
@test2 = [ c d ];
feature rlig { sub @test by @test2; } rlig;
feature liga { sub f i by f_i; } liga;

parser_test responds:

NamedGlyphClass(
    NamedGlyphClass {
        name: GlyphClassName("@test"),
        glyph_class: GlyphClass(
            [
                Single(
                    GlyphRef(name = "a"),
                ),
                Single(
                    GlyphRef(name = "b"),
                ),
            ],
        ),
    },
)

NamedGlyphClass(
    NamedGlyphClass {
        name: GlyphClassName("@test2"),
        glyph_class: GlyphClass(
            [
                Single(
                    GlyphRef(name = "c"),
                ),
                Single(
                    GlyphRef(name = "d"),
                ),
            ],
        ),
    },
)

FeatureDefinition(
    FeatureDefinition {
        tag: FeatureTag("rlig"),
        statements: [
            Substitute(
                Single(
                    Single {
                        prefix: [],
                        glyph_class: GlyphClass(
                            [
                                ClassRef(
                                    GlyphClassName("@test"),
                                ),
                            ],
                        ),
                        suffix: [],
                        replacement: GlyphClass(
                            [
                                ClassRef(
                                    GlyphClassName("@test2"),
                                ),
                            ],
                        ),
                        force_chain: false,
                    },
                ),
            ),
        ],
    },
)

FeatureDefinition(
    FeatureDefinition {
        tag: FeatureTag("liga"),
        statements: [
            Substitute(
                Single(
                    Single {
                        prefix: [],
                        glyph_class: GlyphClass(
                            [],
                        ),
                        suffix: [],
                        replacement: GlyphClass(
                            [],
                        ),
                        force_chain: false,
                    },
                ),
            ),
        ],
    },
)

The rlig rule and the class definitions look good! The liga rule did not seem to work.