If you only need a read-only, baked-in list of items, then there's no benefit in using a Vec. If you aren't planning to change the number of elements, then the Vec is not any more capable than a simple slice, so there's no point in dynamically allocating memory.
Dynamic allocation has not only a performance implication, but also a consequence regarding usability: it's not const, so you can't (easily) put a non-empty Vec in a static or const item. Thus, it's better to default to a slice or an array if you don't need to add or remove elements later.
They're moderately expensive, so a few here or there generally speaking won't be too troublesome, but allocating in a hot code path can really trash your performance.
Not necessarily. Vecs allocate on the heap, but after the allocation is done, for performance it doesn't really matter¹ whether that allocation was on the stack or the heap. Also keep in mind that an array on the stack implies that copying / moving that array will copy/move all of the array, including the elements. In contrast, when moving a Vec, roughly speaking only its ownership is copied or moved. So depending on the use case (e.g. lots of moving stack-allocated arrays around), keeping your data on the stack can hurt performance rather than help it.
¹ We're blissfully skipping over the harsh realities of CPU caching ATM
It is better for a function to accept a slice reference. This way you can pass both slices and Vectors because you can get a slice reference out of a vector. This will even happen implicitly as needed due to Deref coercions.
No, any individual allocation is pretty cheap, especially if you replace the default system allocator with a better one using global_allocator in the binary.
What really matters is pervasive or frequent allocations. Reallocating a buffer every time you read another 3 bytes from a file is a serious performance penalty. Allocating a buffer once to reuse across lots of reads is negligible cost. Allocating a vec![r, g, b] for every pixel in an image is a serious performance penalty. Allocating one big Vec<[u8; 3]> for a whole image is entirely reasonable. Etc.
Vec is good for allocation. It is helpful for example when you have a sequence of elements that you want to convert to bytes or perform some other mapping. If you do it on a &[T], the compiler will complain that the reference does not live long enough, so it must be reassigned. If you have hardcoded values, there is no need for a Vec, but there is not much harm either. Vec is pretty efficient and you can allocate the whole buffer if the number of elements is deterministic.