Grouping rows, and then deleting only a sub range (based on their dates) from each of those groups

You can use subqueries to find whether the current row's time is the min or max within the group. Have to use quotes around the column name since its a reserved SQL keyword. The query below results in the 3 IDs to delete (2,3,9)

select id from calls2 where id not in (
    select calls2.id from calls2 
    join(
        select uid, min("when") minmax from calls2 group by uid
          union all
        select uid, max("when") minmax from calls2 group by uid
    ) mm
    on calls2.uid = mm.uid
    where calls2.when = mm.minmax
)

You can use a CTE to both identify the candidates to delete then use those results to actually perform the delete. This would be necessary only if you needed to record those rows to be deleted. That CTE follows:

with uid_mm( uid      
           , uid_min 
           , uid_max 
           ) as
     ( select uid 
           , min("when") 
           , max("when")
        from calls2
       group by uid 
    )
select * 
  from uid_mm;

Notice, however, this identifies potential deletions for each uid if none actually qualify. You can adjust the CTE to eliminate the non-qualifying rows if needed - but it is not needed. They are eliminated through the main query following the CTE.

with uid_mm( uid      
           , uid_min 
           , uid_max 
           ) as
     ( select uid 
           , min("when") 
           , max("when")
        from calls2
       group by uid 
    )
delete from calls2  c
  where exists ( select null 
                   from uid_mm  u 
                  where c.uid   = u.uid 
                    and c."when" > u.uid_min 
                    and c."when" < u.uid_max
               ); 

See demo here.

You can also use LEAD and LAG over the partition by uid ordered both the same way, the rows to delete are the ones where both results are NOT NULL:

delete from calls2
where id in (
    select 
    case when 
    lag(id) over w is not null 
    and lead(id) over w is not null
    then id
    end as id
    from calls2 c
    window w as(partition by uid order by "when", id)
)

Now the table has gotten way too large, and I like to thin it out

A delete won't actually be enough. It only reclaims space for the same table to re-use over time. If you want to free it fully and make it available for other things, inside or outside the db, you also need a VACUUM FULL. Here's 40k rows holding random dates, belonging to 3k uids, about 4.36MiB before cleanup:
_{demo at db<>fiddle}

select size,pg_size_pretty(size)
from(values(pg_total_relation_size('calls2')))as v(size);

If you don't allow duplicate "when" for the same uid, scan it once to establish earliest/latest for each uid, then delete all else:

with cte as(select uid,min("when"),max("when")
            from calls2
            group by uid)
delete from calls2
where (uid,"when")not in(select uid,min from cte
                         union all
                         select uid,max from cte);

The (x1,y1)=(x2,y2)-style expression uses row constructor comparison syntax. This query also applies if you do allow duplicate dates per uid but you also wish to keep all of the entries that tied for earliest and latest spots. Otherwise:

delete from calls2
where id not in(select distinct on(uid) id
                from calls2
                order by uid,"when" asc,id)
  and id not in(select distinct on(uid) id
                from calls2
                order by uid,"when" desc,id);

And even though these remove 90% of records, the table still takes up 4.36MiB:

select size,pg_size_pretty(size)
from(values(pg_total_relation_size('calls2')))as v(size);

Only once you run the vacuum full, you get that space back:

vacuum(full,analyze,verbose) calls2;
 
select size,pg_size_pretty(size)
from(values(pg_total_relation_size('calls2')))as v(size);

The demo shows plans and exec times for these as well as other queries proposed so far. Note that select benchmarks don't always directly translate to equivalent delete performance because that, by nature, has to persist something on the heap, so the strategies and optimization techniques used by the planner are slightly different.

how I select the other IDs in a way that they list a single row for each uid, showing the uid plus the values of oldest and latest pairs for "when" and "other".

That's the distinct on I used above. You can fetch all the values that coincide with the top/max value in the same row, without aggregation, CTEs, joins, subqueries:

select distinct on(uid) *
from calls2
order by uid, "when", id;

Other RDBMS can emulate it with a row_number() window function in a subquery:

select id, "when", uid
from ( select row_number() over (partition by uid order by "when", id) as rn, *
       from calls ) as subquery
where rn = 1;

plus lots of other statistical information (ip address, query parameters etc)

1. If you aren't already, you can save some space and gain some speed and flexibility by making sure IP addresses use their dedicated inet data type.
2. If some of that additional, undisclosed statistical information is saved using variable length data types (text, json(b), etc.) it might get compressed in place, moved out of line, then compressed out of line. You can save some space by switching default_toast_compression from the default pglz to lz4 offering higher compression ratios. You can also change that for individual columns using alter table..alter column..set compression, as well as control the compression/TOASTing behaviour with alter table..alter column..set storage;
3. It's possible to save a bit more by rearranging the order of your columns to optimise for alignment padding.
4. You can look into pg_repack.

As a curiosity:

delete from calls2
where id not in (select id
                 from calls2
                 window w1 as (partition by uid)
                 order by     1<>row_number()over(w1 order by "when",ctid)
                          and 1<>row_number()over(w1 order by "when" desc,ctid desc)
                 fetch first 1 rows with ties);

• Window functions aren't allowed in a where because they execute after where is already evaluated. This achieves a similar effect by instead using them to establish an order by placing all you're interested in on the same, first position, then fetch 1 rows with ties limits the output to all rows tied for that first position.
• It's looking for rows that don't rank first the top or bottom (1<>row_number()), chronologically. Default order by direction is ascending and false is lower than true, so the first position goes to those that do rank first.
• There are actually three window definitions. The obvious one is the named w1 but then the window function calls use it to establish new ones, with specific ordering.

The three windows and two 1<>row_number() comparisons can be reduced to just one becauase lag=lead yields null if either is null, and order by offers a nulls first option:

delete from calls2
where id not in (
    select id 
    from calls2 c
    window w as(partition by uid order by "when", id)
    order by (lag(id)over w) = (lead(id)over w) nulls first
    fetch first 1 rows with ties );