I can't answer the question "what was the earliest microcomputer Logo implementation", but I can give some details on one early microcomputer Logo implementation, namely MIT Logo.
As ignos has outlined in his excellent answer, LOGO started as a simplified Lisp variant on a PDP-10 mainframe, and then was ported to microcomputers, among those the Apple II.
The source code for Apple II logo has recently been found; it's available on github, and more files and variants are in a sister repository.
Note that development all happened on a PDP-10 under ITS; it's cross-assembled to the Apple II, and it's complete enough you can run this on a PDP-10 emulator, then convert the resulting file to an Apple II disk image, and run this image in an emulator, for example online on archive.org directly in your browser.
So how would the porting process work? You'd need to write a lisp-like interpreter, first for the core functions, then for the rest of the functions; finally you'd hit the space constraints of the microcomputer, and would have to make decisions which parts to keep; you'd tinker with the implementation to compact it and get a bit more space, or you'd add an overlay or paging system etc.
This is of course conjecture to some degree, but if you've ever written programs yourself, you'll know there's not much choice in this. You can see traces of this in various of the files:
DOC.187 mentions three "unwritten" routines,
XFCOMP (which seem to be implemented in the actual code files), so that's the kind of non-core features you won't implement at first and add later.
If you compare
logo.958 (older) with
logo.299 (newer), you'll see
; LOGO: $4000 - $95FF: $5600 bytes (21.5K bytes)
; LOGO: $4000 - $977F: $57FF bytes (22.5K bytes, maximum) Logo code
so in the later stage the code has been tinkered with to allow for more space for the user-defined Logo code (while increasing the interpreter source code size from 209,446 bytes to 278,794 bytes).
And so on.
Actually, LOGO isn't the only system which was ported from a mainframe to micros in this way (using some sort of virtual machine), two others are Zork and UCSD-Pascal (which ended up using paging and overlays, respectively, while LOGO didn't seem to have made this step).
BTW, this LOGO variant ran on a Apple II with 48K and a language card (64K RAM total), no need for an 128K //e or //c. (And I know this from personal experience, because I used it back then on an Apple II).
So you see, if you are
interested specifically in how much of the language could be made to run and how useful it could be in within the constrained resource environment (particularly memory) of early microcomputers,
you (a) cannot dismiss the mainframe code, and (b) cannot restrict yourself to the "earliest" implementation; lots of interesting things happen in the later implementation.
In particular, it probably would be very educating to compare this one to the PDP-11 implementation (also available in the github repositories mentioned) and the original PDP-10 lisp implementation.
So, please, don't ask about "what is the earliest microcomputer implementation of X?" if you are really interested in "how do LOGO implementations on microcomputers deal with the resource restriction on micros?"
These are two completely different things. For the latter, you need the context (like all intelectual exercise, software development doesn't happen in a vacuum): both before (on non-microcomputers) and after (not the earliest variant).