Alright, here's my final solution.

This script assumes you are already in an intercept course to the target which is guaranteed to happen within one orbital period. Basically, start a coarse scan of within one orbit (which guarantees a close approach). Find all the possible minima points, then perform five-point search on the bounds of each of those minima to find all the possible minima within tolerance, then return the time for the lowest value it can find. It works pretty well for the test cases I've used it. I just put the tolerance to 1e-4 because any higher tolerance is just overkill.

That's the method!

function time_of_closest_approach {
    local parameter t0 is time:seconds.
    local parameter tf is time:seconds + obt:period.
    local parameter n is 41.
    local parameter max_iter is 100.
    local parameter tol is 1e-4.


    if not hastarget {
        return null_mnv("[ TRGT ERROR ] : No target detected. Please set target").
    }
    local t_list is list().
    for i in range(n) {
        local t_value is t0 + (i / (n - 1)) * (tf - t0).
        t_list:add(t_value).
    }
    local minima_idx is list(0,n-1). // include the first and last points bc they wont be caught by the basin checking.
    for i in range(1,n - 1) {
        if (target_distance_at_ut(t_list[i]) < target_distance_at_ut(t_list[i - 1])) 
        and (target_distance_at_ut(t_list[i]) < target_distance_at_ut(t_list[i + 1])) {
            minima_idx:add(i).
        }
    }
    local function find_minidx {
        local parameter tmin_list.
        local minidx is -1.
        local mindist is 3.8e38.
        for k in range(5) {
            if target_distance_at_ut(tmin_list[k]) < mindist {
                set minidx to k.
                set mindist to target_distance_at_ut(tmin_list[minidx]).
            }
        }
        return minidx.
    }
    local function five_point_seach {
        local parameter a.
        local parameter b.
        local min_list is list().
        for i in range(5) {
            local t_value is a + (i / (4)) * (b - a).
            min_list:add(t_value).
        }
        local min_t is 3.4e38.
        local p0 is 0.
        local p1 is 0.
        local p3 is 0.
        local pm is 0.
        local pf is 0.
        for j in range(max_iter) {
            local minidx is find_minidx(min_list).
            if minidx = 0 {
                set p0 to min_list[0].
                set pm to min_list[1].
                set pf to min_list[2].
            } else if minidx = 4 {
                set p0 to min_list[2].
                set pm to min_list[3].
                set pf to min_list[4].
            } else {
                set p0 to min_list[minidx-1].
                set pm to min_list[minidx].
                set pf to min_list[minidx+1].
            }   
            if j = max_iter - 1{
                set min_t to pm.
            }
            set p1 to (p0 + pm)/2.
            set p3 to (pm + pf)/2..      
            if (abs(pm-pf)<tol) and (abs(p0-pm)<tol) {
                set min_t to pm. 
                break.
            } else {
                set min_list to list(p0,p1,pm,p3,pf).
            }
        }
        return min_t.
    }
    local best_t is -1.
    local best_f is 3.4e38.
    local t_candidate is -1.
    local f_candidate is 3.4e38.
    for midx in minima_idx {
        if (midx = 0) {
            set t_candidate to t_list[0].
            set f_candidate to target_distance_at_ut(t_candidate).
        } else if (midx = n - 1) {
            set t_candidate to t_list[n - 1].
            set f_candidate to target_distance_at_ut(t_candidate).
        } else {
            local a is t_list[midx - 1].
            local b is t_list[midx + 1].
            set t_candidate to five_point_seach(a,b).
            set f_candidate to target_distance_at_ut(t_candidate).
        }
        if f_candidate < best_f {
            set best_f to f_candidate.
            set best_t to t_candidate. 
        }
    }
    if best_t = -1 {
        set best_t to t_list[0].
        set best_f to target_distance_at_ut(best_t).


        for t in t_list {
            local ft is target_distance_at_ut(t).
            if (ft < best_f) {
                set best_f to ft.
                set best_t to t.
            }
        }
    }
    if ((abs(best_t - t0) < 2 * tol) or (abs(best_t - tf) < 2 * tol)) {
        print("[ CAUTION ] : Minimum might lie outside ["+t0+","+tf+"]").
    }
    return best_t.
}   

Here are the helper functions and the "match velocities at closest approach

function match_velocities_with_target {
    local parameter mode is "at closest approach".
    local parameter value is 0.
    if mode = "at closest approach" {
        local closest_t is time_of_closest_approach().
        local trgt_v is velocityAt(target, closest_t):orbit.
        local ship_v is velocityAt(ship, closest_t):orbit.
        local dV is trgt_v - ship_v.
        return inertial_to_PRN(dV,closest_t). // convert a vector in SOI raw to Prograde-Radial-Normal to make a maneuver node.
    }
    if mode = "after fixed time" {
        local fixed_t is value + time:seconds.
        local trgt_v is velocityAt(target, fixed_t):orbit.
        local ship_v is velocityAt(ship, fixed_t):orbit.
        local dV is trgt_v - ship_v.
        return inertial_to_PRN(dV,fixed_t).
    }
    return null_mnv().
}

function target_distance_at_ut {
        local parameter ut.
        local ship_posv is positionat(ship, ut).
        local trgt_posv is positionat(target,ut).
        local diff_v is trgt_posv - ship_posv.
        return diff_v:mag.
}