When you say <FILE>, the readline result is stored in a special variable called a "targ" (target) associated with that particular readline call (it's more complicated if there's recursion or threading) and the assignment copies the value. The special variable holds on to its allocated space for reuse the next time the readline is executed (if ever). This is why you see twice the space allocated in the do{} case.

There are two optimizations that can prevent it; one is that a number of different operations that normally use a targ switch to using an arbitrary scalar when their result is being assigned to it by scalar assignment. Compare the direct assignment vs. the assignment with an intermediary operation:

$ perl -MO=Concise,-exec -we'my $foo = scalar <STDIN>'
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v
3  <#> gv[*STDIN] s
4  <1> readline[t3] sK/1
5  <0> padsv[$foo:1,2] sRM*/LVINTRO
6  <2> sassign vKS/2
7  <@> leave[1 ref] vKP/REFC
-e syntax OK
~$ perl -MO=Concise,-exec -we'my $foo = <STDIN>'
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v
3  <0> padsv[$foo:1,2] sRM*/LVINTRO
4  <#> gv[*STDIN] s
5  <1> readline[t3] sKS/1
6  <@> leave[1 ref] vKP/REFC
-e syntax OK
[download]

(The scalar() operation itself is optimized away, but nevertheless interferes with the other optimization.) Note that the sassign operation disappears and readline takes the sv to read into as an extra argument (to which it is alerted by the extra S (STACKED) flag).

The other optimization that prevents readline from using its targ is specific to readline. When you catenate onto a buffer, the readline and concatenation operations are joined into a single rcatline operation:

$ perl -MO=Concise,-exec -we' $foo.=<STDIN>'
Name "main::foo" used only once: possible typo at -e line 1.
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v
3  <#> gvsv[*foo] s
4  <#> rcatline[*STDIN] sS
5  <@> leave[1 ref] vKP/REFC
-e syntax OK
[download]