well it takes at most $$$m\log(n)$$$ operations for $$$m$$$ calls and it will eventually be in $$$O(1)$$$... But this does not imply that after doing any kind of $$$m$$$ calls the following calls will be in $$$O(1)$$$. And we don't do $$$m$$$ calls, we actually do $$$m\log(n)$$$ calls. Therefore I am not sure about the complexity... (It could still be true but I am not sure and a basic analysis only results in $$$O(m\log(n)^2)$$$)

My implementation would look like this:

struct edge {
    ll a, b, w, id;

    bool operator<(const edge& o) const {
        if (w != o.w) return w < o.w;
        return id < o.id;
    }
};

vector<bool> boruvka(ll n, vector<edge> edges) {
    vector<bool> res(edges.size());
    while (!edges.empty()) {
        //find local minimal edges
        vector<ll> minEdge(n, -1);
        for (ll i = 0; i < edges.size(); i++) {
            if (minEdge[edges[i].a] < 0 || edges[i] < edges[minEdge[edges[i].a]]) minEdge[edges[i].a] = i;
            if (minEdge[edges[i].b] < 0 || edges[i] < edges[minEdge[edges[i].b]]) minEdge[edges[i].b] = i;
        }
        //build graph with local minimal edges
        vector<vector<ll>> adj(n);
        for (ll x : minEdge) {
            if (x < 0) continue;
            res[edges[x].id] = true;
            adj[edges[x].a].push_back(edges[x].b);
            adj[edges[x].b].push_back(edges[x].a);
        }
        //find components
        vector<ll> c(n, -1);
        ll cs = 0;
        for (ll i = 0; i < n; i++) {
            if (c[i] >= 0) continue;
            vector<ll> s = {i};
            c[i] = cs;
            while (!s.empty()) {
                ll x = s.back();
                s.pop_back();
                for (ll y : adj[x]) {
                    if (c[y] >= 0) continue;
                    c[y] = cs;
                    s.push_back(y);
            }}
            cs++;
        }
        //update
        n = cs;
        for (ll i = 0; i < edges.size();) {
            edges[i].a = c[edges[i].a];
            edges[i].b = c[edges[i].b];
            if (edges[i].a == edges[i].b) {
                swap(edges[i], edges.back());
                edges.pop_back();
            } else {
                i++;
            }
        }
    }
    return res;
}