GroupBy after SelectMany in EF Core

Consider the following query, which lists the Schools, along with monthly statistics for the students that started that month at the school.

 _dbContext.Schools
  .Select(p => new MySchoolView
  {
    School= p,
    MonthlyStatistics = p.Teacher
      .SelectMany(d => d.Students)
      .GroupBy(d => new { d.StartDate.Month, d.StartDate.Year })
      .Select(g => new MonthlyStatisticsView
        {
          Year = g.Key.Year,
          Month = g.Key.Month,
          Count = g.Count(),
          Dollars = g.Sum(d => d.Tuition)
        }).ToList()
  })

EF Core chokes on this query:
> System.InvalidOperationException: Unable to translate a collection subquery in a projection since either parent or the subquery doesn't project necessary information required to uniquely identify it and correctly generate results on the client side. This can happen when trying to correlate on keyless entity type. This can also happen for some cases of projection before 'Distinct' or some shapes of grouping key in case of 'GroupBy'. These should either contain all key properties of the entity that the operation is applied on, or only contain simple property access expressions.

However, it is able to handle a similar query, if we calculate the monthly statistics based on the Teacher table, instead of the student table:

 _dbContext.Schools
  .Select(p => new MySchoolView
  {
    School= p,
    MonthlyStatistics = p.Teacher
      .GroupBy(d => new { d.EmploymentDate.Month, d.EmploymentDate.Year })
      .Select(g => new MonthlyStatisticsView
        {
          Year = g.Key.Year,
          Month = g.Key.Month,
          Count = g.Count(),
          Dollars = g.Sum(d => d.Salary)
        }).ToList()
  })

I believe that this is due to EF Core not being able to handle the .SelectMany before the .GroupBy. Is there a way that EF Core can handle a query like this, e.g. by directly navigating from the School to the Student or otherwise rewriting the SelectMany using other operations?

I already know about the following possibilities, which are not viable solutions for me:

1. Using client side evaluation instead
2. Breaking the query into N queries
3. Restructuring the database

I would suggest another approach which is still performant but translatable. Preparing grouped data and then post process on the client side.

var query = 
    from s in _dbContext.Schools
    from t in s.Teacher
    from st in t.Students
    group st by new { s.Id, st.StartDate.Month, st.StartDate.Year } into g
    select new 
    {
        Id = g.Key.Id,
        Year = g.Key.Year,
        Month = g.Key.Month,
        Count = g.Count(),
        Dollars = g.Sum(d => d.Tuition)
    } into d
    join s in _dbContext.Schools on d.Id equals s.Id
    select new 
    {
        School = s,
        Details = d
    };

var rawData = query.ToList();

var result = rawData
    .GroupBy(r => r.School.Id)
    .Select(g => new MySchoolView
    {
        School = g.First().School,
        MonthlyStatistics = g.Select(s => new MonthlyStatisticsView
        {
            Year = s.Details.Year,
            Month = s.Details.Month,
            Count = s.Details.Count,
            Dollars = s.Details.Dollars
        }).ToList()
    });