This was causing all our metaprogramming that checked types to break.
See: nodejs/node#13827

This is necessary for avoiding cases where even accessing the property
will set off a getter, or blow up in strict mode (e.g. accessing
arguments or caller/callee on something). Instead, we'll look at the
descriptor's `value` property, which is relatively "inert" by comparison

When copying props, you can adjust the value with a func arg

Does not work but figured like I may as well save my place

Should overwrite fields, but only if they're both writable &
configurable. If the target has a field that's somehow neither of these,
then it's almost certainly some kind of built-in like
Function.prototype.length

It no longer needs the original because it has the full property
descriptor

This required using the most-valuey of types as base cases in the
recursion, because it'd muck with the perceived value of things like
Date and moreover would fake 30+ string methods for probably zero
benefit and lots of confusion. (Only affects boxed instances of these
prims)

Surprisingly lodash isEqual fails on two errors but only if one is
cloned. Meanwhile, assert module will pass deepEqual on two errors if
the messages differ. Fantastic

Push all the naming chains into the imitation object, since it's the
only call site with sufficient context

This got the tests passing, but may save us the need for extending
types options (thanks to just using prototype and not class syntax)

Add a Map polyfill to get things working under older browsers, also
refer to Symbol in such a way that it's backwards compatible

I did this in an example project to be sure it was a native (not
transpiled) class being "extended" by td.js. This is the case that was
failing during the 2.x series and necessitated the extendCo… option
for 3.x

This test passes, so we can delete that option next

The improvements in the new imitate function sidestep the babel class
extension issue that prompted the introduction of this option. All fakes
will pass instanceof checks as a matter of course now.

Of course, this means that a major bump will be necessary, since that
config option will have been removed and anyone setting it will blow up…

I feel like I earn 3 points for lazily giving people a
let-me-github-that-for-you URL and lose 2 points for lazily pasting in
an error message

Doing this in prep of adding a second teenytest suite under test/safe

Also we stopped printing '#' as shorthand for 'prototype'. It was
complicating the code, and on further reflection it makes the messages
harder for anyone who's not "in the know" with respect to '#' being a
symbol for "instance method" (as opposed to '.' for plain function)

This refactor started by teasing the tangled function into its separate
roles, then pushing the behavior down into 3 new units.

The unit test for the refactored thing is particularly interesting,
because it required use of argument captors to trigger the downstream
behavior. This was necessary because the method was recursive, and we
needed to invoke the subject twice, once indirectly. It's hard to find
good examples of argument captors, so here you go.

Turns out most of the logic was pretty dumb and it's new behavior so I
just axed most of it

These are just the node-level replacement, their properties (or for
arrays, elements) will be replaced by overwriteChildren

Simplied somewhat, when I learned through the test that underscore's
clone works well enough for primitives (one would trust, efficiently
enough)

Lots of complexity got swept under this rug, really causing some pain at
the periphery. Since it's a leaf node, will I ever look at it again?
Probably not.

Some notes:
  * ../../../.. is outrageous. I should figure out how to go about
  getting the unit tests colocated with the source soon.
  * 5 arguments for chain-prototype.js? Seriously? That can't be
  necessary
  * This overwrite-children/index test is really the kitchen sink of
  edge cases for delegator objects. It has replaced deps, it has one-off
  test double functions passed as arguments, it has argument captors for
  getting callbacks under isolated tests, it has verifications that
  certain dependencies were absolutely not called. It's got it all!

  All of these are smells that this unit is weird/awkward. It's possible that
  things got complex because the code originated while  trying to tidy up the
  behavior originally in the context of a big method with lots of closure-scoped
  variables available. That explains the 5 arg function (once extracted
  and closure-scope is lost), as well as the visitor pattern sort of
  callbacks to keep the recursion step out-of-sight of the extracted
  unit.

  Unsure how I'd rework it at this point to breathe like a normal
  function, though. That's why I should have test-drove this from
  scratch instead of test-aftering and pushing down all these things!
  Whoops!