Are there problems in $DTIME(n^k) - DTIME(n^{k-1})$ that are not hard for $DTIME(n^{k-1})$ under nearly linear time reductions?
The answer to the question is yes, assuming that (for all large $k$) $k$-SUM is not in $\text{DTIME}(n^{o(k)})$.
It also follows (by a result of Patrascu and Williams) that the answer is yes assuming the ETH holds.
The proof reuses the classical technique from the classical proof that, if any unary language is NP-hard, then P=NP.
Definitions

The question: Does there exist $k \geq 2$ such that there exist problems in $\text{DTIME}(n^k) - \text{DTIME}(n^{k-1})$ that are not computationally hard for $\text{DTIME}(n^{k-1})$ under nearly linear-time reductions?

The $k$-SUM problem: Given $n$ integers, are there $k$ of them that sum to zero?

ETH (the Exponential Time Hypothesis): 3-SAT is not in $\text{DTIME}(2^{o(n)})$.


Result
Theorem 1. Assume that (for all $k$), $k$-SUM is not in $\text{DTIME}(n^{o(k)})$.  Then the answer to the question is yes.
Proof. We show the contrapositive.  Assume that the answer to the question is no.  As observed in the post, this implies that, for all sufficiently large $k$, there is a unary language that is hard for $\text{DTIME}(n^k)$ under nearly linear-time reductions.  To complete the proof we show the following:
Lemma 1. Assume that, for some $c\ge 1$, for all sufficiently large $k$, there is a unary language that is hard for $\text{DTIME}(n^k)$ under $O(n^c)$-time reductions.  Then, for all $k$, $k$-SUM is in $\text{DTIME}(n^{2c+1}) \subseteq \text{DTIME}(n^{o(k)})$.
Proof. Fix such a $c\ge 1$ and an arbitrarily large $k$. Let $L\subseteq 1^*$ be the unary language that is hard for $\text{DTIME}(n^{k+1})$ under $O(n^c)$-time reductions.
Define the following generalization of $k$-SUM, called $k$-SUM'.  The input consists of $n$ integers, a target $t$, and a budget $d\le k$.  The question is whether any $d$ of the given integers sum to $t$.
To prove the lemma, we describe an $n^{O(c)}$-time algorithm for $k$-SUM' (which clearly generalizes $k$-SUM).
As $k$-SUM' is easily in $\text{DTIME}(n^{k+1})$, by definition of $L$ there is an $O(n^c)$-time reduction, say $f$, from $k$-SUM' to the unary language $L$.
We use the classical technique from the proof that, if there is an NP-hard unary language, then P=NP.  Namely, consider the following dynamic-programming algorithm for $k$-SUM' (presented here in recursive memoized form):

input: $k$-SUM' instance $I=((x_1, x_2, \ldots, x_n), t, d)$

if $n=0$ or $d=0$, return 'true' if $t=0$ and 'false' otherwise  (base case)

compute the reduction $f(I) \in 1^*$ (the time this takes and $|f(I)|$ are both $O(n^c)$)

if we've previously computed the answer for an instance $I'$ with $f(I')=f(I)$, return the same answer for $I$.  otherwise:

let $I_0$ be the $k$-SUM' instance $((x_1, x_2, \ldots, x_{n-1}), t, d)$

let $I_1$ be the $k$-SUM' instance $((x_1, x_2, \ldots, x_{n-1}), t-x_n, d-1)$

recursively compute the answers for $I_0$ and $I_1$

the answer for $I$ is 'true' iff the answer to $I_0$ is 'true' or the answer to $I_1$ is 'true'

memoize the answer for $I$ in the lookup table, under index $f(I)$

return the answer for $I$


The algorithm is correct by standard dynamic-programming reasoning along with the observation that any two $k$-SUM' instances that reduce to the same element of $L$ must have the same answer.
How much time does it take?
For each subproblem (not counting the recursive calls) the time is dominated by the the time to compute $f(I)$, which is $O(n^c)$.
Each subproblem $I'$ that arises in the recursion has size $O(n)$, so $f(I')$ is of the form $1^m$ for $m = O(n^c)$.  Thus, the number of &quot;distinct subproblems&quot; (whose answers are not already cached when they arise) is $O(n^{c+1})$ (we get an extra factor of $n$ because if a subproblem $I$ has an ancestor $I'$ with $f(I)=f(I')$, the answer for $f(I')$ won't be cached when $I$ is encountered).  It follows that the recursion tree has $O(n^{c+1})$ nodes, and the total time is $O(n^{2c+1})$.  $~~~\Box$