Word Wrap Algorithm and Datastructure that supports modifications of text and window size
I think you can handle single-word modifications in $O(d \log n)$ time, where $d$ (density) is the maximal number of words in a line, which is hopefully small for any reasonable $A$ and fixed $W$.
Let's take one of your sentences as an example. We want it to be wrapped with $W = 30$ characters like this:
I'm looking for an algorithm
and datastructure that would
allow for linearithmic
preprocessing on A and
something like logarithmic
time modifications and
queries.

First, let's find all possible lines. This can be done greedily in $O(n)$ using two pointers scanning through $A$. If one of these lines ends where the other begins, we connect them.

The path from node $1$ to the root of the tree represents $I_W$.
Now let's remove &quot;an&quot; from the first line, forcing all other lines to shift:
I'm looking for algorithm and
datastructure that would allow
for linearithmic preprocessing
on A and something like
logarithmic time modifications
and queries.

But here's one nice thing about the tree: any single-word change can only affect $O(d)$ edges. We find these edges by re-running the same pre-processing on a small window around the changed word. In our case, the changes are:

Edge 1-6 removed
Edge 4-8 removed
Edge 1-7 added


So, we need to be able to do these operations efficiently:

Add new edge into the tree
Remove existing edge from the tree
Find $k$-th ancestor of a given node.

All these operations can be done in $O(\log n)$ via Euler tour technique. I won't describe its implementation in detail, but feel free to ask a separate question about it.