Lack of cached execution plans when using `IN` clause
1) Is there a recommended way to write these sorts of queries in order
  to bypass this limitation and take advantage of cached execution plans
  (other than using forced parameterization at a database level)?


Paul White explained it here with examples.


  2) How can I evaluate the impact that these queries are having on the
  overall performance of the database (e.g., how can I answer
  quantitatively whether or not it is worth my time to worry about the
  lack of cached execution plans)?


You need do some collection and aggregation for this one. 


Once you compare the performance of your rewrite as explained in Paul's article you know the difference (in io, cpu) for one call + time for recompilation. 
Multiply that by number of calls (of the changed query) in x period.
Add those numbers for all the query you rewrite.
Another approach is to benchmark you overall workload, make change to small number of queries and compare with baseline. 
If moving in the right direction make more changes (provided workload did not change),otherwise go back to starting point. Evaluate one by one.