The unsizing coercion from Box<SomeStruct> to Box<dyn SomeTrait>changes the layout of Box<SomeStruct> and thus can't happen once it's already in the Vec.
If you have to have a Vec<Box<SomeStruct>> or Vec<SomeStruct> for awhile and turn it into a Vec<Box<dyn SomeTrait>> later, you'll need something like
// Vec<Box<SomeStruct>>
v.into_iter().map(|s| s as _).collect()
// Vec<SomeStruct>
v.into_iter().map(|s| Box::new(s) as _).collect()
...but better to just start with and keep the Vec<Box<dyn SomeTrait>> if possible.
Sure. When you coerce from SomeStruct to dyn SomeTrait, the base type (SomeStruct) is erased. The same is true when you coerce from SomeOtherStruct to dyn SomeTrait.
So dyn SomeTrait might have a different size depending on the erased base type. We say it's a dynamically sized type (DST); we also say that it is not Sized (doesn't implement the Sized trait, which means you have a statically known size), or that it is unsized. The coercion is a form of unsized coercion.
Because they are unsized, you generally see dyn SomeTrait behind some kind of pointer or reference, like &dyn SomeTrait. The way it works is that these pointers / references are wide -- instead of being one pointer that points to the value, they are two pointers: one to the value, and another to a vtable for the trait. The vtable contains things like the size of the base type and pointers to all the methods of the trait.
Internally, Box<T> acts like an owning *mut T to the value of the T. If T happens to be unsized, then the *mut T is wide, just like above.
The main non-dyn DST in Rust is the slice, [T]. In the case of slices, the wide pointers / references include a usize recording the length of the slice (the number of elements) instead of a vtable. There is also limited support for custom DSTs which are wrappers over the built-in DSTs. (More robust custom-DST support may be added eventually).
There are other DSTs you're familiar with which are basically typed wrappers around a slice: str, OsStr, and so on.
because while there is a generic with Box::new, it has to be a Box::<SomeStruct>::new here.
The as _ let's the compiler know that "hmm, they want to cast the Box<SomeStruct> to some type I'm supposed to infer (_)", and it can't tell what that is without looking at the wider context to see you need it to be a Box<dyn SomeTrait>.
You could spell it out with as Box<dyn SomeTrait>, but I'm lazy