Lerp to target position in X amount of time

 using System.Collections;
 using UnityEngine;
 
 public class ItemLaunch : MonoBehaviour
 {
     /// <summary>
     /// The player to target
     /// </summary>
     [SerializeField]
     private Transform player;
 
     /// <summary>
     /// The curve giving the throw amplitude according
     /// to the distance to the player
     /// </summary>
     [SerializeField]
     private AnimationCurve distanceToAmplitudeFunction ;
 
     /// <summary>
     /// The start position
     /// </summary>
     private Vector3 startPosition;
 
     /// <summary>
     /// The target position
     /// </summary>
     private Vector3 targetPosition;
 
     /// <summary>
     /// The coroutine
     /// </summary>
     private IEnumerator coroutine;
 
     // Use this for initialization
     void Start ()
     {
         // Called in the Start method for the example,
         // but you can call it whenever you want
         // Here, I use an animation curve to determine the amplitude,
         // but you can use a plain function, like Vector3.Distance( player.position, transform.position ) * 2 for instance
         // or Mathf.Exp( Vector3.Distance( player.position, transform.position ) )
         Launch( 1, distanceToAmplitudeFunction.Evaluate( Vector3.Distance( player.position, transform.position ) ) );    
     }
 
     /// <summary>
     /// Launches the item
     /// </summary>
     /// <param name="duration">The flight duration.</param>
     /// <param name="amplitude">The throw amplitude.</param>
     public void Launch( float duration, float amplitude )
     {
         startPosition = transform.position;
         targetPosition = player.position;
 
         if ( coroutine != null )
             StopCoroutine( coroutine );
 
         coroutine = Fly( duration, amplitude );
         StartCoroutine( coroutine );
     }
 
     /// <summary>
     /// Flies during the specified duration
     /// </summary>
     /// <param name="duration">The flight duration.</param>
     /// <param name="amplitude">The throw amplitude.</param>
     /// <returns></returns>
     private IEnumerator Fly( float duration, float amplitude )
     {
         if ( duration > Mathf.Epsilon )
         {
             for ( float progress = 0 ; progress < duration ; progress += Time.deltaTime )
             {
                 transform.position = Vector3.Lerp( startPosition, targetPosition, progress / duration ) + Vector3.up * Mathf.Sin( progress / duration * Mathf.PI) * amplitude;
                 yield return null;
             }
         }
         transform.position = targetPosition ;
         coroutine = null;
     }
 }

@b2hinkle Here you are using Lerp in the Update function with the start position as the current transform position. The transform position is also updated in the same function causing the pickup item to move closer to the player every frame. This is a common approach but the movement will seem rather independent of time. To make it time dependent, keep the start position constant and gradually change the lerp factor every frame. This can be achieved as follows- In the start method, initialize a timer = 0f. This timer will be our lerp factor and will go from 0 to 1 where timer at 0 denotes that the pickup is at the start position and 1 denotes that it has reached the player. In the update method, try this -

 timer += Time.deltaTime/n;
 if (timer<1){
 transform.position = Vector3.Lerp(startPosition, player.transform.position, timer);
 }

Please note that here n denotes the no. of seconds taken for the coin to move from its start position to the player.

Setting n = 1 will complete the journey in 1 second, =2 in 2 seconds and so on. Adjust it to get the required speed. Also note that in the Lerp function, my first argument is the startPosition (which you have initialized in the Start method and doesn't change with time for this item instead of transform.position which was being changed every frame in your code. Hope it works!