[GENERAL] WindowAgg optimized out of subquery but not out of CTE, generating different results.

I am having an issue where the subquery version of a query and the CTE version of a query are generating different results.
Postgresql version 9.5.5 on Linux Ubuntu 14.04.

Table definition:
      Table "dealerinventorychange"
    Column     |     Type     |     Modifiers     
---------------+--------------+--------------------
 dealerid      | integer      | not null
 modelid       | integer      | default 0
 trimid        | integer      | not null default 0
 inventorydate | date         | not null
 sold          | integer      | default 0
 arrived       | integer      | default 0
 inventory     | integer      | default 0
Indexes:
    "dealerinventorychange_pkey" PRIMARY KEY, btree (dealerid, trimid, inventorydate)

So I have this query that involves a window function to select the most recent rows of given criteria on or before a date from this table of about 4M rows.
For the modelid, dealerid, and inventorydate filter criteria in this particular example query, 2 different trimids and 8 total rows from the table should be selected for the window function to operate on.
The intent of the window function used in combination with DISTINCT ON is to select the most recent inventorydate row for each trimid that is no later than the cutoff date.

The CTE version of the query plan selects the correct two rows to sum:
with foo as (
      select distinct on (dealerid, trimid)
                  dealerid, trimid, inventorydate, sold, arrived, inventory,
                  first_value(inventorydate) over (partition by dealerid, trimid order by inventorydate desc range between unbounded preceding and unbounded following) as closest_date
      from dealerinventorychange where dealerid=21358 and modelid = 2272 and inventorydate <= '2016-12-31')
select sum(inventory) from foo;

Result:
 sum
-----
   9
(1 row)

The CTE query generates the following query plan:
                                                                             QUERY PLAN                                                                            
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Aggregate  (cost=4100.59..4100.60 rows=1 width=4) (actual time=2.739..2.739 rows=1 loops=1)
   CTE foo
     ->  Unique  (cost=4100.56..4100.57 rows=1 width=37) (actual time=2.719..2.733 rows=2 loops=1)
           ->  WindowAgg  (cost=4100.56..4100.57 rows=1 width=37) (actual time=2.717..2.730 rows=8 loops=1)
                 ->  Sort  (cost=4100.56..4100.56 rows=1 width=37) (actual time=1.388..1.389 rows=8 loops=1)
                       Sort Key: dealerinventorychange.trimid, dealerinventorychange.inventorydate DESC
                       Sort Method: quicksort  Memory: 25kB
                       ->  Bitmap Heap Scan on dealerinventorychange  (cost=50.15..4100.56 rows=1 width=37) (actual time=1.294..1.375 rows=8 loops=1)
                             Recheck Cond: ((dealerid = 21358) AND (inventorydate <= '2016-12-31'::date))
                             Filter: (modelid = 2272)
                             Rows Removed by Filter: 1840
                             Heap Blocks: exact=209
                             ->  Bitmap Index Scan on dealerinventorychange_pkey  (cost=0.00..50.15 rows=2737 width=0) (actual time=0.679..0.679 rows=5249 loops=1)
                                   Index Cond: ((dealerid = 21358) AND (inventorydate <= '2016-12-31'::date))
   ->  CTE Scan on foo  (cost=0.00..0.02 rows=1 width=4) (actual time=2.721..2.735 rows=2 loops=1)
 Planning time: 0.161 ms
 Execution time: 3.979 ms
(17 rows)

The subquery version of the query selects the wrong two rows to sum.
select sum(inventory) from
      (select distinct on (dealerid, trimid)
                  dealerid, trimid, inventorydate, sold, arrived, inventory,
                  first_value(inventorydate) over (partition by dealerid, trimid order by inventorydate desc range between unbounded preceding and unbounded following) as closest_date
      from dealerinventorychange where dealerid=21358 and modelid = 2272 and inventorydate <= '2016-12-31')
as foo;

Result:
sum
-----
   2
(1 row)

The subquery query generates the following query plan:
                                                                         QUERY PLAN                                                                        
------------------------------------------------------------------------------------------------------------------------------------------------------------
 Aggregate  (cost=4100.57..4100.58 rows=1 width=4) (actual time=1.981..1.981 rows=1 loops=1)
   ->  Unique  (cost=4100.56..4100.56 rows=1 width=16) (actual time=1.969..1.977 rows=2 loops=1)
         ->  Sort  (cost=4100.56..4100.56 rows=1 width=16) (actual time=1.966..1.968 rows=8 loops=1)
               Sort Key: dealerinventorychange.trimid
               Sort Method: quicksort  Memory: 25kB
               ->  Bitmap Heap Scan on dealerinventorychange  (cost=50.15..4100.56 rows=1 width=16) (actual time=1.812..1.956 rows=8 loops=1)
                     Recheck Cond: ((dealerid = 21358) AND (inventorydate <= '2016-12-31'::date))
                     Filter: (modelid = 2272)
                     Rows Removed by Filter: 1840
                     Heap Blocks: exact=209
                     ->  Bitmap Index Scan on dealerinventorychange_pkey  (cost=0.00..50.15 rows=2737 width=0) (actual time=0.843..0.843 rows=5249 loops=1)
                           Index Cond: ((dealerid = 21358) AND (inventorydate <= '2016-12-31'::date))
 Planning time: 0.245 ms
 Execution time: 2.052 ms
(14 rows)

The subquery version appears to optimize out the WindowAgg and simplifies the sort to just on trimid for some reason, and thus selects the wrong two rows for the Unique step.
Without the sort by inventorydate, the query picked the two inventorydates furthest from the cutoff date (in this instance).
Is this supposed to happen given the queries above? Why? Is there some sort of interaction happening between the missing DISTINCT ON ORDER BY and the window ORDER BY? is this a bug?

If I add filter criteria in the outer query to force the right rows to be selected by the outer query in the subquery version, I get the following query plan:

select sum(inventory) from
      (select distinct on (dealerid, trimid)
                  dealerid, trimid, inventorydate, sold, arrived, inventory,
                  first_value(inventorydate) over (partition by dealerid, trimid order by inventorydate desc range between unbounded preceding and unbounded following) as closest_date
      from dealerinventorychange where dealerid=21358 and modelid = 2272 and inventorydate <= '2016-12-31')
as foo
where inventorydate = closest_date;

Result:
sum
-----
   9
(1 row)

                                                                               QUERY PLAN                                                                              
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Aggregate  (cost=4100.58..4100.59 rows=1 width=4) (actual time=1.639..1.639 rows=1 loops=1)
   ->  Subquery Scan on foo  (cost=4100.56..4100.58 rows=1 width=4) (actual time=1.614..1.634 rows=2 loops=1)
         Filter: (foo.inventorydate = foo.closest_date)
         ->  Unique  (cost=4100.56..4100.57 rows=1 width=16) (actual time=1.610..1.630 rows=2 loops=1)
               ->  WindowAgg  (cost=4100.56..4100.57 rows=1 width=16) (actual time=1.609..1.626 rows=8 loops=1)
                     ->  Sort  (cost=4100.56..4100.56 rows=1 width=16) (actual time=1.602..1.603 rows=8 loops=1)
                           Sort Key: dealerinventorychange.trimid, dealerinventorychange.inventorydate DESC
                           Sort Method: quicksort  Memory: 25kB
                           ->  Bitmap Heap Scan on dealerinventorychange  (cost=50.15..4100.56 rows=1 width=16) (actual time=1.377..1.547 rows=8 loops=1)
                                 Recheck Cond: ((dealerid = 21358) AND (inventorydate <= '2016-12-31'::date))
                                 Filter: (modelid = 2272)
                                 Rows Removed by Filter: 1840
                                 Heap Blocks: exact=209
                                 ->  Bitmap Index Scan on dealerinventorychange_pkey  (cost=0.00..50.15 rows=2737 width=0) (actual time=0.518..0.518 rows=5249 loops=1)
                                       Index Cond: ((dealerid = 21358) AND (inventorydate <= '2016-12-31'::date))
 Planning time: 0.161 ms
 Execution time: 1.686 ms
(17 rows)

The WindowAgg comes back now after I put the filter on the outer query. Why?

This behavior in postgres is confusing the heck out of me.
Thanks in advance to anyone who can explain this discrepancy.
B. Yeh