Your goals are not achievable.
You want the running time to be $O(K)$, where $K$ is the number of layers (or the distance from the source to the destination, I'm not sure which). However, this running time is not achievable. Suppose we have only a handful of layers, but millions of vertices in each layer: say, $K$ layers, but $N/K$ vertices per layer, where $K$ is small and $N$ is large). Then there is no way to get a running time of $O(K)$, because any solution will have to look at every vertex in each of those layers. Therefore, the best you can hope for is a worst-case running time of $O(N)$; $O(K)$ isn't achievable.
So, there is no algorithm that will meet your constraints.
That's the bad news. The good news is that there is an algorithm that is efficient and has a running time that is asymptotically optimal. This is the standard algorithm for computing shortest paths in a DAG: you topologically sort the DAG, then visit the vertices in topologically sorted order, calling "Relax" on each edge. Any good algorithms textbook is likely to describe this algorithm.
The running time of this algorithm is linear, i.e., $O(V+E)$. One can also prove that this is the best worst-case running time one can hope for: it's not possible to do any better, in terms of asymptotic worst-case running time. So, from a theoretical perspective, the standard algorithm is excellent.
Now this doesn't rule out the possibility that clever implementation can improve the constant factors. Indeed, it is likely that careful consideration of things like the structure of your graphs and the memory hierarchy might yield speedups that are measurable in practice. But you shouldn't expect an improvement in the asymptotic running time.