Optimal path through a DAG with sparsely available edge weights
Your question is not self-consistent, so you first need to figure out exactly what you are looking for, before we can identify an algorithm to find it.

However, once you figure that out, it is likely that dynamic programming will solve your problem.  Dynamic programming is powerful and likely to solve your problem for any reasonable criterion that depends only on detail and erraticism (assuming it is monotonic in each variable separately).

In particular, define $f(v,d)$ as follows:


  $f(v,d) = $ the smallest possible erraticism that can be achieved by a path from $A$ to $v$ whose detail is $d$.


In other words,

$$f(v,d) = \min \{\text{erraticism}(p) : p \text{ is a path from $A$ to $v$ and } \text{detail}(p)=d\}.$$

Let $\text{pred}(v)$ denote the set of vertices $u$ such that there is a path from $u$ to $v$ where you have the metric for $u$ but not for any other intermediate vertex in the path (i.e., not for any other vertex in the path other than $u$ or $v$).

Notice you can compute $f(v,d)$ given the values of $f(u,c)$ for all $u \in \text{pred}(v)$ and all integers $c$ satisfying $0 \le c \le d$.  Call this "formula (*)".

Since the graph is guaranteed to be a dag, you can linearize it (topologically sort it).  Then, visit the vertices in topologically sorted order.  When you visit $v$, compute $f(v,d)$ for each possible $d$ using formula (*) -- this is possible because the topological sort ensures you will have computed $f(u,c)$ before visiting $v$.

There are $|V|$ possible vertices and at most $|V|$ possible values for the detail.  Calculating $f(v,d)$ can be done in $O(|V|)$ time, since the set $\text{pred}(v)$ has size at most $|V|$.  Therefore, the running time of this will be at most $O(|V|^3)$.

In practice, I expect the algorithm will be faster than that.  For instance, you only need to compute $f(v,d)$ for $d=0,1,2,\dots,\ell$, where $\ell$ is the length of the shortest path from $A$ to $v$.  Also, for most vertices, the size of $\text{pred}(v)$ will usually be much less than $|V|$ -- maybe more like $O(1)$.

Once you have computed $f(Z,0),f(Z,1),f(Z,2),\dots$, where $Z$ is the final node, then you can use all of that information to select which path you want.  For instance, if your criterion is "minimize erraticism, and break ties in favor of greater detail", you just compute $\min \{f(Z,d) : d=0,1,2,\dots\}$, resolving ties in favor of the larger $d$.  As another example, if you want to modify that criterion by ignoring all paths with detail 0, just ignore $f(Z,0)$.  Or, if you want to ignore all paths with detail 0 if there exists any path with detail $&gt; 0$, then check whether any of $f(Z,1),f(Z,2),\dots$ are finite ($&lt; +\infty$); if yes, then you ignore $f(Z,0)$.  And so on.  Hopefully you can see how to adapt the dynamic programming solution to handle many possible variations for the objective function.

For specific objective functions, there might well be even more efficient solutions -- but since it is not clear from your question at the time of writing just what objective function you want to minimize, I thought I would outline a general answer that works for a large class of possible objective functions.