class SchemePointBase {}
class SchemePoint : SchemePointBase {}

interface ISchemeGlyph
{
    IEnumerable<SchemePointBase> Points {get;}
}

class SchemeItemList<T> : IList<T> {} // базовый список

class PointList : SchemeItemList<SchemePoint> {}
class GlyphList : SchemeItemList<ISchemeGlyph> {}

class Scheme
{
   GlyphList Glyphs { get; }
   PointList Points { get; }
}

        let points = seq { 
            yield! scheme.Points :> seq<SchemePoint> :?> seq<SchemePointBase>
            yield! Seq.collect (fun (glyph: ISchemeGlyph) -> glyph.Points) scheme.Glyphs
            }

J>        let points = seq { 
J>            yield! scheme.Points :> seq<SchemePoint> :?> seq<SchemePointBase>
J>            yield! Seq.collect (fun (glyph: ISchemeGlyph) -> glyph.Points) scheme.Glyphs
J>            }
J>

open System.Collections.Generic

type SchemePointBase() = class end
type SchemePoint() = inherit SchemePointBase()
type ISchemeGlyph =
     abstract member Points : SchemePointBase seq

type SchemeItemList<'T>() = inherit List<'T>()
type PointList() = inherit SchemeItemList<SchemePoint>()
type GlyphList() = inherit SchemeItemList<ISchemeGlyph>()

type Scheme() =
     member this.Glyphs = GlyphList()
     member this.Points = PointList()

let scheme = Scheme()
let points = seq {
    yield! scheme.Points |> Seq.cast<_>
    yield! scheme.Glyphs |> Seq.collect (fun g -> g.Points)
  }

J>        let points = seq { 
J>            yield! scheme.Points :> seq<SchemePoint> :?> seq<SchemePointBase>
J>            yield! Seq.collect (fun (glyph: ISchemeGlyph) -> glyph.Points) scheme.Glyphs
J>            }
J>

        let points = seq { 
            for i in scheme.Points do yield i
            for i in scheme.Glyphs do yield i
            }

        let points = seq { 
            for i in scheme.Points do yield i
            for xs in scheme.Glyphs do for i in xs do yield i
            }

П>>На самом деле иерархии наследования, реализации интерфейсов и ко-/контравариантность создают определённые сложности для вывода типов, а у Вас тут как раз полный букет...

scheme.Glyphs |> Seq.collect (fun glyph -> glyph.Points)
(* что эквивалентно *)
(|>) scheme.Glyphs (Seq.collect (fun glyph -> glyph.Points))
(* что, в свою очередь, эквивалентно *)
((|>) scheme.Glyphs) (Seq.collect (fun glyph -> glyph.Points))

Seq.collect (fun glyph -> glyph.Points) scheme.Glyphs
(* эквивалентно *)
(Seq.collect (fun glyph -> glyph.Points)) scheme.Glyphs

let flip f x y = f y x
flip Seq.collect (fun glyph -> glyph.Points) scheme.Glyphs

KO>scheme.Glyphs |> Seq.collect (fun glyph -> glyph.Points)
KO>(* что эквивалентно *)
KO>(|>) scheme.Glyphs (Seq.collect (fun glyph -> glyph.Points))
KO>(* что, в свою очередь, эквивалентно *)
KO>((|>) scheme.Glyphs) (Seq.collect (fun glyph -> glyph.Points))
KO>

KO>Seq.collect (fun glyph -> glyph.Points) scheme.Glyphs
KO>(* эквивалентно *)
KO>(Seq.collect (fun glyph -> glyph.Points)) scheme.Glyphs
KO>

KO>let flip f x y = f y x
KO>flip Seq.collect (fun glyph -> glyph.Points) scheme.Glyphs
KO>

let inline (|>) x f = f x

type seq<'T> = System.Collections.Generic.IEnumerable<'T>

public interface IEnumerable<out T> : IEnumerable

let points = seq { 
    yield! scheme.Points :> seq<SchemePoint> :?> seq<SchemePointBase>
    }

    class Program
    {
        class Base { }
        class Child : Base { }
        class Other { }
        static void Main(string[] args)
        {
            List<Child> childList = new List<Child>();
            IEnumerable<Base> baseEnum = (IEnumerable<Base>)childList;
        }
    }

KO>type seq<'T> = System.Collections.Generic.IEnumerable<'T>
KO>

KO>public interface IEnumerable<out T> : IEnumerable
KO>

using Nemerle.Collections;
using System;
using System.Collections.Generic;

class SchemePointBase { }
class SchemePoint : SchemePointBase { }

public interface IEnumerable2[+T] { GetEnumerator() : object; }

interface ISchemeGlyph { Points : IEnumerable2[SchemePointBase] { get } }

class SchemeItemList[T] : IEnumerable2[T] { public GetEnumerator() : object { null } }

class PointList : SchemeItemList[SchemePoint] {}
class GlyphList : SchemeItemList[ISchemeGlyph] {}

class Scheme
{
  public Glyphs : GlyphList { get; set; }
  public Points : PointList { get; set; }
}

public module Program
{
  public static Concat[TSource](this _first : IEnumerable2[TSource], _second : IEnumerable2[TSource]) : IEnumerable2[TSource]
  {
    throw NotImplementedException()
  }
  
  public MapLazy[From, To](this _source : IEnumerable2[From], _convert : From -> To) : IEnumerable2[To]
  {
    throw NotImplementedException()
  }

  public Flatten[TEnu, TOut](this _source : IEnumerable2[TEnu]) : IEnumerable2[TOut]
    where TEnu : IEnumerable2[TOut]
  {
    throw NotImplementedException()
  }

  Main() : void
  {
    def scheme = Scheme();
    _ = scheme.Points.Concat(scheme.Glyphs.MapLazy(_.Points).Flatten());
  }
}